Operating receipts
Build narratives on Claude Code, API, and MCP
For practitioners and recruiters who want to see past the thesis. This page covers how I build production systems, not what I believe about them.
Multi-model honesty: Claude is my primary daily driver. I also run Codex for certain agent patterns and have production experience with Gemini through Google Cloud work. The builds below are Claude-primary unless noted.
Build narrative
Document-intelligence pipeline under bad inputs
Healthcare document intake is not "AI reads PDFs." It's sideways faxes, coffee-ring stains over patient IDs, handwritten amendments, and pages that arrive out of order. I built a multi-stage pipeline on AWS that handles this reality.
Architecture: Document models for classification and extraction, workflow rules that route by document type and urgency, patient-matching logic that handles partial identifiers, and escalation paths for low-confidence cases. Multi-model fallback chain — Claude handles the language understanding; vision models handle the preprocessing disasters.
The human queue: What lands on someone's desk at 8 a.m. matters more than aggregate accuracy. The system prioritizes keeping that queue actionable — clear cases with clear reasons for escalation, not a pile of "AI wasn't sure."
Hard part: Confidence thresholds. Set them too low and you flood the human queue. Set them too high and you miss exceptions that matter. We tune per document type and retrain when error patterns shift. There's no one-time calibration.
Build narrative — public
EvalGPT: PRD judge with evidence-verified scoring
Most PRD review is vibes. "Looks good" or "needs more detail" without structure. I built an end-to-end PRD evaluation service that produces binary verdicts, deterministic scores, and agent-ready task graphs.
Architecture: React frontend → Fastify gateway on Cloud Run → private Python judge runtime. Split architecture keeps the scoring logic isolated and auditable. Privacy-preserving Google auth with HMAC-pseudonymous quotas; no PRD content persists after evaluation.
Scoring: GO/REVISE/HOLD verdicts against C1–C12 rubric criteria. Evidence quotes are checked against the source, and unverifiable citations fail closed. Pinned judge bundles and model allowlists prevent drift between evaluations.
Hard part: Making PASS/FAIL and fix plans trustworthy enough to feed downstream agents. If the judge is wrong, the agents implement the wrong thing at machine speed. The verification layer is the product.
Build narrative
CMS claim-rule mining from COBOL with Claude
Extracting Medicare pricing and claims rules from legacy COBOL into English rules with source traceability (2026, ongoing). Claude mines the rules; a test corpus checks them against black-box pricer behavior.
What Claude does: Mining claim-processing rules into plain English. Grounding extracted rules to original COBOL source so reviewers can verify. Building the test corpus that proves extracted rules match black-box pricer behavior. This is repo-scale legacy comprehension with Claude as the core engine.
Related work: Semantic AST analysis for allocation-system migrations (Informix 4GL → Java). The pattern is the same — you don't rewrite until you can defend the rules in a format humans and agents can verify.
Hard part: Models fail on legacy semantics. A partial AST is not a migration plan. Making those systems legible is the prerequisite — and it's exactly the kind of hard domain that stresses model capabilities and requires serious evaluation.
Heritage
A decade breaking black boxes — before LLMs
The modernization work didn't start with Claude. At Pivotal, I built the AppTx Radar — an interactive assessment tool for replatform-vs-modernize decisions. Authored the surgery-pattern taxonomy (Strangler, ACL, seams, Mikado Method) used across Pivotal modernization engagements.
Presented at InfoQ and SpringOne on monolith decomposition with DDD, Event Storming, and observable health assessment.
The difference now: Claude can do in hours what took weeks of manual code archaeology. But the hard problems — rule extraction, behavior verification, domain expert validation — are the same. The craft transfers.
Operating note
Day-to-day with Claude Code and MCP
I run Claude Code as my primary development environment across multiple repositories. For production customer work, this means parallel agent sessions — some executing work orders, some running adversarial review on completed artifacts, some maintaining shared context across the project.
The MCP ecosystem is where I spend significant architecture time. Custom servers for code indexing, document pipelines, and customer-specific integrations. Skills for structured reasoning patterns that customers need repeatedly. The craft is knowing when a problem needs a custom tool versus better prompting.
Operating intensity is high — daily, multi-hour work across multiple production contexts. But the intensity is evidence of operating mode, not skill proof. Knowing when to switch from agent execution to manual inspection matters more than hours logged.
Demos and secondary builds
Other public artifacts
Clinical diagnosis engine (demo)
Configurable YAML clinical-rules DSL with Claude vision extraction from handwritten rules. Real-time criteria evaluation. Labeled as demo — not a clinical product.
View on GitHub →Consult automation agent
Claude Agent SDK pipeline: Gmail invite triage, profile-aware accept/decline, dual Computer Use stack for form fill. Personal ops automation demonstrating agentic loop ownership.
View on GitHub →Methodology note: I maintain a local analytics dashboard over my Claude usage (Code, .ai, Desktop, API) — pure-stdlib Python, no network dependencies, engagement metrics with gap caps. The tool exists to understand my own patterns, not to produce vanity stats.