Facilities maintenance by trade. Self-taught AI systems builder by curiosity.
I didn't come into this through computer science or a software career.
I came into it by building things.
Usually I find something I want to understand, start messing with it, break something, figure out why it broke, and keep following the thread until I'm several layers deeper than where I started.
AI sped that process up a lot.
A few years ago I was mostly trying to understand what these models could do. Now I spend a ridiculous amount of my free time working on agent systems, local models, orchestration, evaluation, memory, retrieval, and the software underneath all of it.
I didn't sit down one day and decide to become an AI systems builder.
I just kept following interesting problems.
Eventually I looked around and realized I was building systems.
So that's what I'm calling it.
Most of my projects end up somewhere around:
- agent systems and orchestration
- local-first AI
- memory, retrieval, and persistent state
- evaluation and small decision models
- deterministic infrastructure underneath model-driven systems
One question keeps coming back:
What should the model decide, and what should the system already know?
That has become a pretty useful way for me to think about things.
If the machine already knows something exactly, I'd rather let normal software handle it.
Models are much more interesting to me when the answer is fuzzy, contextual, semantic, or hard to turn into a clean rule.
A lot of what I'm doing now is figuring out where that line actually belongs.
I use AI heavily.
There really isn't any point pretending otherwise.
A lot of what I can build today is possible because I can work with models that help me research, reason through problems, write code, inspect systems, and explain things I don't understand yet.
At the same time, I don't want to spend all day babysitting agents and approving every tiny action.
I want enough visibility and control that I can understand what the system is doing, change direction when I need to, and know what happened when something goes wrong.
Beyond that, I want the system to be capable of actually doing work.
I'm still figuring out what that balance looks like.
It's not really one chatbot doing everything anymore.
Different models end up being useful for different parts of the work, and those roles move around depending on what we're doing.
Me
I set direction, make architecture decisions, run experiments, decide what gets accepted, and keep responsibility for the final result.
ChatGPT
My main thinking and orchestration partner. We work through ideas, research, experiment design, architecture, results, project continuity, and documentation together.
Codex, Claude, and other coding agents
Usually implementation, debugging, review, repository work, or another approach when I want a second set of eyes.
Local models
These are increasingly becoming parts of the systems themselves. I care less about whether they're the biggest model available and more about whether they have the right job, context, and tools.
Jev, Laya, embeddings, rerankers, and other smaller models
Specialists. Relevance, ranking, conflict detection, routing, or other narrow judgments where a full general-purpose model would be overkill.
None of those roles are absolute.
Sometimes the coding agent helps with architecture. Sometimes ChatGPT writes code. Sometimes a local model surprises me.
The point is mostly that I don't expect every model to be good at everything.
My day job is facilities maintenance.
The more I learn about software, the more I realize that background probably affects how I approach this stuff.
If something breaks, I want to know why.
If I fix it, I want to know whether I actually fixed it.
If a machine says one thing and reality says another, reality wins.
I also don't like being responsible for systems I can't inspect.
None of that started as a software philosophy. It's just how I've always approached equipment and systems, and it followed me here.
I started using AI because it let me do things I couldn't do before.
Then I got curious about the tools themselves, which led into agents, memory, local models, orchestration, evaluation, and eventually all the boring deterministic pieces underneath them.
Funny enough, those boring pieces keep turning out to be some of the most interesting parts.
I'm still following the thread.
AI is a huge part of how I build.
I'm not embarrassed by that.
It would be dishonest to act like I sat alone and hand-wrote every line from first principles, because I didn't.
I work with models constantly, and I learn a lot from doing it.
My job in that relationship is to understand enough to make decisions, question bad output, test what matters, and stay responsible for what gets built.
If AI disappeared tomorrow?
I'd probably go back to being pretty average.
Just considerably more knowledgeable than I was before. 😂
I'll take that trade.
For a long time I kept a lot of this work private because I didn't think I knew enough yet to put it out there.
I'm trying to stop doing that.
This GitHub is becoming the public trail of what I'm building, what works, what doesn't, and what I learn along the way.
Some of it will hold up.
Some of it probably won't.
That's okay.
I'd rather leave the trail.
If you're interested in AI systems, agents, local models, evaluation, human-AI collaboration, or learning complicated things by building them, you'll probably find something around here worth poking at.