Connect
Let's build something
Open to full-time roles, contract work, and collaborations, especially anything that puts AI into production software.
I build high-volume production systems in C#, React, and SQL Server. Lately, I've been wiring those same skills into LLMs, RAG pipelines, and multi-agent workflows, all running on local GPU hardware.
Side projects with open repos, live demos, and build logs. The three that shipped lead with their measured results.
Multi-agent code review for pull requests: an orchestrator fans a diff out to specialized quality, security, and docs agents, then synthesizes their findings into one ranked review. Agents reach real tools (Roslyn, Semgrep, the GitHub API) through MCP. The public, from-scratch version of PR automation I built at work.
Ask plain-English questions against your documents and get cited answers back. A C#/.NET RAG pipeline with swappable providers: the same code runs fully local (Ollama + ChromaDB) or on Azure (OpenAI + AI Search) by flipping one config value. The live demo answers questions about me.
Predictive maintenance as a complete MLOps loop: failure-prediction models trained on NASA turbofan sensor data, deployed to Azure through secretless CI/CD (OIDC, no stored keys), and watched for distribution shift with Evidently. The drift is real, not simulated: held-out operating regimes replay as production traffic, and when metrics cross threshold the pipeline retrains a challenger and a human approves the promotion. Six phases, built in public, with a live dashboard that reads the same log the monitor reads.
Benchmarks and fine-tuning studies on a pair of NVIDIA DGX Sparks. Not that Spark. The flagship experiment LoRA fine-tunes a 7–14B open model and asks whether it can replace the frontier model inside AgentReview's Quality Agent at matching precision and recall for near-zero cost per review, with everything but the model frozen at a tagged commit. Seven working weekends, one binary exit test per phase, every result traced to an MLflow run. The two-Spark link was proven first with a 320B model served across both nodes; that detour lives in the Lab, not in the experiment.
The way I work with AI coding agents, written down as a system: skills, agents, prompts, templates, and workflows so every ticket, review, and deploy gets the same care. All of it is plain markdown that works with Claude Code, Copilot, or Cursor, and it installs as a Claude Code plugin in two commands.
An end-to-end NLP pipeline that scores tweet sentiment and flags bot accounts with a 13-feature XGBoost classifier, serving live predictions through a Discord bot. Even back then, trained models were RSA-signed and verified at load time so the inference layer never runs a tampered pickle.
Authored XML API documentation adapting archived XNA reference material, adding platform-specific remarks for DirectX, DesktopGL, iOS, and Android runtime behavior.
Fixed the solar cell's implausible half-meter longest_side and added looks_like sprite fallbacks for the Xedra Evolved dream weapons, across two merged pull requests.
Standardized the Japan trivia answer format to support multiple accepted answers per question and added a 「〜ても」 grammar entry, across two merged pull requests.
Found a hardcoded Azure Cognitive Services endpoint and live API key exposed in a public course sample and submitted the security fix replacing the credentials with placeholders.
For the past 7+ years, I've been building the kind of software that can't go down: C# APIs, SQL Server architectures, React frontends, all running at scale for companies that process serious volume. One system I optimized validated over a trillion dollars in historical records. Another tool I shipped cut a team's monthly support tickets by 90%.
Everything on this page is proof you can check yourself: certifications with one-click credential links, projects with open repos and live demos, and benchmarks run on hardware I own. The full work history is available on request.
Now I'm taking all of that production discipline and applying it to AI. I'm building RAG apps, experimenting with multi-agent systems, fine-tuning open models on my own pair of NVIDIA DGX Sparks, and stacking certifications that reflect hands-on skill.
Production .NET and data engineering at the core, with an expanding AI and ML toolkit on top.
The foundation is a computer science degree. The proof is everything below it: verified certifications and projects you can actually open and run.
I pick certifications that prove I can build, not just define terms.
Cloud concepts, Azure services, security, privacy, compliance, and pricing
Building and deploying Azure Cognitive Services, AI solutions, and knowledge mining pipelines
Training, evaluating, and deploying ML and GenAI models with Azure Machine Learning and Microsoft Foundry
Git fundamentals, GitHub collaboration, repositories, workflows, and project management
AI-assisted development, prompt crafting, Copilot configuration, and responsible AI usage
Building MCP servers that give LLM-powered apps structured access to tools and data
Agentic coding workflows, terminal-based AI development, and real-world Claude Code usage
Designing and implementing reusable agent skill modules for AI-powered workflows
Orchestrating multi-agent systems with subagent delegation and task decomposition
Deploying production agents on AgentCore Runtime with Identity, Gateway, Memory, and Observability
Multi-agent communication patterns, agents as tools, shared memory, evaluation, and distributed tracing
The classic web app list: broken access control, injection, cryptographic failures, and insecure design
Broken object and function level authorization, broken authentication, and missing rate limits
Prompt injection, sensitive data disclosure, excessive agency, and the other OWASP risks for LLM apps
Agent goal hijack, tool misuse, privilege abuse, and the other OWASP risks for autonomous agents
Fine-tuning, benchmarking, and multi-agent experiments on the two DGX Sparks sitting on my desk.
Running models on my own hardware means I can experiment without watching API costs climb, keep data completely private, and iterate on model behavior without hitting rate limits or usage caps. When you own the compute, you move faster.
The DGX Spark's unified memory lets me load models that would normally require multiple consumer GPUs. Two of them bridged over ConnectX-7 go further: they hold a 320B mixture-of-experts model between them, served tensor-parallel with vLLM behind an OpenAI-compatible endpoint that VS Code talks to like any hosted model. What that took is written up, and so is the first thing I asked the model to build: SparkDash, a dashboard for its own server, built in one agent session against a spec and scorecard written beforehand.
Notes, tutorials, and the occasional postmortem from the move into AI engineering.
Six phases, 21 days, and every number measured. The wrap-up on DriftWatch: what it produced, what it cost, what broke, and what's still not done.
AgentReview shipped. Three specialized agents reviewed 8 seeded PRs with 18 planted bugs and came back with 100% precision, 17/18 recall, and a cost of $0.068 per review. The one miss is written up honestly in the README.
I made DocQuery's entire AI stack swappable with a single config value, then raced a MacBook, an NVIDIA DGX Spark, and Azure against each other. The results overturned most of my assumptions about fast and cheap in local versus cloud inference.
Google's Antigravity SDK just added local model support, and the architecture it enables — cloud planners delegating to local executors — is one of the most practically useful patterns I've seen for real enterprise AI workloads.
Strata, a new C++ engine, runs Qwen3.8-Flash-Next, a 125B mixture-of-experts model with 6B active parameters, on a single consumer GPU. The 8GB in the headline is the floor its own docs say runs slowly. Why MoE makes this work, where the rest of the weights live, and what I'd check before pointing an agent at it.
Google Cloud API Gateway can now expose your existing REST APIs as native MCP tools with a few OpenAPI annotations. The annotation is the easy part. Before you mark up everything, your endpoints need to make sense to a caller that never read your docs.
Open to full-time roles, contract work, and collaborations, especially anything that puts AI into production software.