Building reliable systems through evidence and careful engineering
I'm an AI consultant and systems architect specializing in translating complex regulations into reliable tools. My approach combines rigorous testing, evidence-based decision-making, and a deep skepticism toward unnecessary complexity.
Who I Am
I build production systems that handle complexity without collapsing under it. My background spans OSHA compliance automation, AI agent methodology, and deterministic systems architecture. What unites this work is a commitment to evidence over opinion—testing more than talking, building less, thinking more.
I started without a technical background but learned to work with AI systems to ship production code. This taught me something valuable: domain expertise + careful prompting often beats traditional software architecture. It also taught me the opposite: technical excellence without customer validation is expensive and lonely.
Philosophy
My operating principles guide every decision, from architecture to copy:
≥95% Confidence Threshold
I don't implement or claim something works unless I'm at least 95% confident. Below that threshold, I declare uncertainty openly rather than guess. This prevents hallucinated solutions and forces better investigation.
Brutal Simplicity
Simplicity always wins. Complexity must justify itself with evidence. If a simple solution works, the elegant solution is often the simple one. This applies to architecture, copy, design, and business decisions.
Filesystem as Truth
Test output, git diffs, and actual measurements are the source of truth—not opinions or intentions. Before proposing solutions, I verify problems exist. Before claiming completeness, I measure.
Binary Outcomes
Work is either SAT (satisfied all criteria with evidence) or UNSAT (failed, with specific analysis why). There's no "ready for review" or "looks good." This clarity prevents wasted time on half-finished work.
Conservative Bias
When rules are ambiguous, I choose the safer interpretation. This applies to OSHA compliance (classify as recordable when uncertain), regulatory interpretation, and system design. Safety over cleverness.
How I Work
My approach is shaped by lessons from shipping production systems and failed experiments:
Evidence-Based Development
Every claim is backed by test output, measurements, or git diffs. No "should work" or "probably." This means testing more than typical, but shipping with confidence more than typical.
Contract-Driven Design
I define "done" before starting—specific criteria, verification methods, edge cases. This prevents scope creep and creates clear stopping points. The OSHA tool had 13 compliance clauses that fully defined success.
Validate With Customers First
Building beautiful solutions to nonexistent problems is expensive. I ask customers before I code. This mistake cost me months on an accounting tool nobody wanted—lesson learned once, learned hard.
Determinism Over Cleverness
Systems that behave the same way twice are worth more than systems that are theoretically optimal. I build for predictability and testability, not elegance or generalization.
Constraints Force Better Design
The OSHA tool shipped in 3 months partly because it had zero external dependencies. Constraints eliminate options, which eliminates decision paralysis. Sometimes limitations are features.
Failing Publicly Beats Failing Privately
I share learnings from projects that didn't ship. The accounting tool taught me about market validation, template scaling, and the cost of building without customers. Those lessons are more valuable than success stories.
The Builder Journey
This work started from zero technical background. Here's how I learned to build production systems:
Operator-Ledger: The Knowledge System
Built a context-map for AI agents—YAML + markdown as state, with session ingestion pipelines. Proved that filesystem-as-truth works for multi-agent coordination. 100% test coverage. No external dependencies.
OSHA Compliance Tool: Evidence-Based Shipping
Built a production form generator that handles OSHA recordkeeping. Shipped in 3 months with 13-clause contract. 100% test coverage. Handles messy inputs (texts, emails, workers comp claims) and generates compliant forms. Taught me that constraints and clarity beat complexity every time.
Accounting Automation: The Expensive Lesson
Built a bank statement parser with 100% accuracy and 208 tests. Production-ready, offline-first, privacy-focused. But it solved a problem nobody had (QuickBooks commoditized the market). Zero customer conversations before building. Shelved after market validation. Cost me months and taught me the most valuable lesson: build WITH customers, not FOR imagined customers.
Platform & Teaching
Built a platform for consulting services and started documenting my methodology for others. Teaching non-technical founders how to work with AI agents to ship production code. The next chapter: helping others avoid my mistakes.
What I Do
I offer consulting and custom development in three areas:
Compliance Automation
Translate complex regulations into reliable tools. OSHA recordkeeping, tax form generation, permit automation—anything that turns scattered rules into systematic workflows.
AI Agent Methodology
Teaching non-technical founders how to collaborate with AI to build production systems. How to give clear requirements, verify outputs, test systematically, and ship with confidence.
Deterministic Systems Architecture
Designing systems that are testable, predictable, and maintainable. Applying contract-driven development, evidence-based decision-making, and simplicity-first principles to your architecture.
Let's Build Something Careful Together
Whether you're building compliance tools, learning to work with AI agents, or designing deterministic systems, I'm interested in projects where simplicity, evidence, and careful engineering matter.