Software craftsmanship, responsible AI, leadership lessons from chemical plants, and the messy reality of building things that work.
My oldest came skidding around the corner in socks on hardwood — eyes wide, voice cracking with the particular urgency that only an eight-year-old whose Minecraft world is under siege can produce.
Every morning at 6:15, before the coffee kicked in, we stood in front of the board. Five letters. Big. Color-coded. Red or green. Just the board, telling you the truth about your operation whether you wanted to hear it or not.
Your MVP has a procurement process to survive. A security review. A compliance checklist. A VP who put their name on the approval. It has to live in that world from day one.
One of our AI agents rewrote a function, ran the tests, watched them pass, and shipped it. Except the function was wrong. The tests passed because the agent had also written the tests, and the tests were checking for the wrong thing.
Teams are building AI features with none of the discipline they'd apply to literally any other part of their system. No tests around the AI integration. No clean interface. No fallback behavior when the model hallucinates.
I was sitting at my desk with six AI agents running in six terminal panes, and I couldn't tell what any of them were doing. I was the air traffic controller, except the radar was broken and the planes were texting me in paragraphs.
Last week I committed a Secure cookie flag to production that only worked on localhost. The AI helped with all of it. Enthusiastically.
I decided to save my original EPIC drawings by laminating them, only to remember I'd drawn them with a heat-sensitive erasable pen. In that one decision, the original drawings were gone.
Spending ten years in chemical manufacturing is not the typical path to preparing for a career in software development. But that's what I did. Here's what I learned about shopping for software solutions.
From a toddler's one-word school report to building a full production platform — a reflection on growth, persistence, and the slow accumulation of craft.
On the importance of testing and what happens when you skip it — told through the lens of learning TDD from scratch.
Life lessons from toddlers, applied to software development. Sometimes the simplest observations cut the deepest.
Observations from raising kids while learning to code — where the mundane becomes metaphor.
The apprenticeship continues. Learning, failing, growing — with colorful commentary from the peanut gallery at home.
That particular feeling when you're stuck on a problem and growing at the same time. The apprenticeship grind, unvarnished.
Recursion, explained — twice. When code calls itself and toddlers repeat themselves, the parallels are uncanny.
Kids say the darndest things. So do error messages. Reflections from the intersection of parenting and programming.
Learning to refactor code while learning to let go. The apprenticeship diaries continue.
HTTP status codes explained through the universal language of cats. Because sometimes the best way to learn protocols is through memes.
Planning the path forward — apprenticeship roadmaps, learning plans, and figuring out what to tackle next.
The title says it all. Parenthood meets apprenticeship in the most unglamorous way possible.
Drag and drop, explained. Also dragons. The early apprenticeship blog entries where code concepts meet creative storytelling.
The very beginning. Starting a software apprenticeship with two small kids, a chemical engineering background, and zero idea what I was getting into.
I wanted to learn how to code, but I neither knew where to start or what that path forward might look like. A decade of false starts before finding the right approach.