Featured Projects

The Mission

"Safe, assistive coverage answers that build trust instead of tickets."

Today, employee benefits are under-used because people do not know what is covered, how much is left, or where to look. That confusion turns into avoidable HR tickets, slower claim submission, and weak perceived value, which hurts activation and renewals in a new market. In Canada, getting a coverage answer wrong is not just a user experience bug; it erodes trust and bumps into provincial compliance and PHI privacy risk.

This prototype explores a low-risk way for Canadian benefits platforms to increase employee engagement while keeping admins out of the help-desk role and staying inside strict compliance boundaries.

The Solution

A Ruby on Rails 7 assistant that adds an assistive-only benefits chat interface on top of structured coverage rules and balance data. It uses AI for intent classification, executes strongly-typed “function” calls to fetch the right rules and balances, and gracefully falls back to human support tickets when confidence is low or AI is disabled.

How It Works

When an employee asks a question like, “How much massage therapy is left?” the system:

• Determines intent using a mix of pattern matching and AI classification.
• Dispatches to executor functions that fetch coverage rules and balances from structured data.
• Generates natural-language responses that cite specific limits, rules, and disclaimers.
• Falls back to support ticket creation if AI is disabled, fails, or confidence is below threshold.

Safety & Compliance

The prototype is built with privacy, reversibility, and auditability as non-negotiable constraints:

• PII redaction (names, phones, emails) is applied before any external AI call.
• A feature flag (AI_CHAT_ENABLED) allows instant rollback to human-only flows.

Tech Stack

The Mission

"Suggestions-only conflict checks that make intake faster and more defensible."

Manual conflict checks often burn 30–60 minutes per new client and are inconsistent to document. That slows intake completion, weakens trust, and makes it harder for firms to prove that conflicts were checked properly.

This prototype explores a low-blast-radius way to move conflict-hint surfacing from minutes to seconds, make documented clearance the default via an attached log, and keep humans firmly in the loop.

The Solution

A safe, suggestions-only conflict-check assistant that runs on intake, surfaces ranked matches for reviewer decision, and writes an immutable audit log. It is feature-flagged, reversible, and avoids schema changes, so it can plug into Clio-style intake without destabilizing existing workflows.

How It Works

When a new intake is submitted, the service:

• Runs a fuzzy similarity scan across existing clients, prior/alias names, related parties, and matter titles.
• Returns a ranked list of Suggested Conflicts with reasons in a side panel.
• Lets the reviewer mark each suggestion as Cleared or Escalate after review.
• Writes a timestamped Conflict Check Log (reviewer, inputs, decision) for each intake.

The posture is strictly assistive: the system never hard-blocks intake, and all suggestions and logs respect existing matter and user permissions (ethical walls).

Safety & Trust

The design focuses on speeding review without creating new risk:

• Suggestions ≠ decisions: lawyers remain the final decision-makers.
• Permissions-aware: suggested conflicts and logs respect existing ethical walls.
• Feature-flagged via CONFLICT_COLLECTOR_ENABLED for instant rollback.
• Immutable logging: every conflict check is captured for later audit and defensibility.

Tech Stack

The Mission

"Clarity without chaos. Turn intention into action."

This app helps thoughtful, high-performing individuals turn their goals into focused daily action using AI assistance and minimal interface friction. The mission is to reduce decision fatigue and increase execution through intelligent daily planning grounded in SMART goals.

The Solution

A React Native (Expo) mobile app with AI-powered task management, featuring OpenAI GPT-4o integration for intelligent planning and Supabase backend for seamless data management.

The app includes custom memory layers to track user's SMART goals & task history, with token budgeting middleware to keep AI costs low while maintaining intelligent assistance.

Tech Stack

The Mission

"Don't bet a product on extraction quality you haven't measured."

High-value document workflows — pulling obligations, dates, parties, and limits out of PDFs — assume you can extract the right facts and know where they came from. Those assumptions are expensive if they're wrong. Most AI-over-documents demos look plausible in a chat window and fall apart when you ask: which facts did it miss, which citations are fake, and what did that run cost?

This project is not a scaled-down product. It is a measurement instrument: a local Django harness that runs controlled experiments on real PDFs so architecture, model, prompt, and processing choices are made with evidence instead of guesswork.

The Solution

A Django 6 test harness that treats extraction as an experiment, not a feature. You freeze a corpus, annotate the facts you already know are in the documents, then run the same files through different AI models, prompts, schemas, and processing strategies. The system scores each run against that ground truth, reports precision/recall/F1 plus provenance accuracy, and breaks down token usage, latency, and cost — including cost per correct fact.

A separate prompt-evaluation module isolates prompt design from full-document extraction. It generates and compares prompt variations against a large set of test cases and a scoring rubric. That work made a concrete lesson unavoidable: small wording changes can produce drastically better results, but only if you can measure them.

How It Works

When you run an extraction experiment, the system:

• Processes PDFs into pages and text regions with bounding boxes (PyMuPDF), then freezes them into an immutable corpus snapshot.
• Uses your approved annotations — expected facts plus quoted evidence — as the scoring key.
• Extracts facts through a chosen strategy: whole-document, section-based, two-pass, or hybrid (deterministic extractors plus the model).
• Calls OpenAI, Anthropic, or Gemini through a shared adapter layer, with versioned prompts and JSON schemas.
• Matches extracted facts to ground truth with deterministic scoring (not an LLM-as-judge), including source/provenance checks (page and region overlap).
• Writes an evaluation report and a cost/performance report for that run, so you can compare strategies on quality and spend.

Prompt Evaluation

When you evaluate prompts instead of full documents, the system:

• Loads a frozen set of test cases (input text + expected JSON output).
• Renders prompt variations (direct instruction, chain-of-thought, few-shot, and other tweaks).
• Scores each variation with a weighted rubric and pluggable scorers.
• Reports average/median score, success rate, and timing so you pick a prompt before paying for a full corpus run.

Rigor & Traceability

The harness is built so a surprising number can be traced back to a document, a prompt, and a dollar amount:

• Every run snapshots corpus, annotations, model, strategy, prompt, and schema so experiments are reproducible.
• Facts are graded against human-authored ground truth, with diagnostics when metrics collapse (the usual culprit: missing evidence links).
• Provenance is scored, not assumed — citations have to land on the right page/region.
• Token-level instrumentation records historical pricing, latency percentiles, retries, and cost per correct fact.
• Adjacent sandboxes test questions a production system will hit next: how to represent extracted relationships, multi-tenant authorization patterns, and where document data actually flows for Canadian residency analysis (technical evidence, not legal certification).

Tech Stack

The Mission

"Give every project the same disciplined agent workflow — without baking one stack's habits into another."

Coding agents are powerful, but most projects start from scratch: a half-written AGENTS.md, one-off prompts, and skills that hardcode pytest, npm, or cargo. That inconsistency slows onboarding, breaks when a teammate uses a different IDE, and fails in cloud agents that never saw your local setup. The result is fragile AI assistance — useful for the author, unreliable for the team.

Reusable AI Infrastructure explores a low-friction way to turn "how I work with agents" into stack-agnostic infrastructure that lives inside each repo.

The Solution

A Bash + Markdown initializer that interviews you about a target project, drafts a project-specific AGENT.md from a template, and copies a curated payload of agent skills and dev-process docs into that repo. Skills stay domain-neutral: they read commands from AGENT.md instead of hardcoding a stack. Copies are real files, not symlinks, so the destination is self-contained after setup.

How It Works

When you point it at a project:

• An init-project skill inspects the repo, interviews you about purpose and stack, and drafts AGENT.md.
• init.sh copies skills, conventions, and process docs into .cursor/skills and .claude/skills, with safe conflict modes (abort, skip, overwrite + backup).
• Skills cover the full delivery loop: brainstorming, ticket implementation with TDD, commits, PR descriptions, opening PRs, and keeping AGENT.md current.
• update.sh reports which initialized projects are missing or drifted vs the payload; you choose what to write back with --skills-only.

Design Constraints

Built so agent infrastructure stays portable, auditable, and non-destructive:

• Domain-neutral payload — leak tests fail if stack-specific terms sneak into skills.
• Conflict-safe installs — default abort; overwrite backs up to .ai-init-backup/.
• Opt-in updates — update.sh reports only; nothing silently overwrites destinations.
• Dual-tool install — same skills for Cursor and Claude Code from one registry (skills.json).

Tech Stack

The Mission

"Build muscle memory for clean design—not just memorize the acronym."

Most developers can recite SRP, OCP, LSP, ISP, and DIP. Far fewer can spot those violations under real pressure, explain why they hurt, and refactor without breaking behavior. Tutorial blogs and slide decks leave a gap: you never struggle with messy, realistic code long enough for the patterns to stick. That shows up later as rigid classes, untestable modules, and costly rewrites when requirements change.

This project turns SOLID from theory into a repeatable practice loop—identify, refactor, compare, and get structured feedback—so design judgment becomes habit instead of trivia.

The Solution

A multi-language practice repository of timestamped challenges. Each challenge ships intentional SOLID antipatterns in a realistic domain (reports, auth, file storage), plus a reference fix. Cursor Agent Skills extend the loop: one skill scaffolds new challenges in Ruby, JavaScript, Python, or C#; another reviews your refactoring like a senior engineer—without inventing violations or spoiling the learning.

How It Works

When you open a challenge like Employee Report Creator or File Storage Manager, the workflow is:

• Analyze the _with_errors file and hunt for SRP, OCP, LSP, ISP, and DIP issues yourself.
• Refactor into your own solution, documenting why each change matters.
• Compare against the _with_fixes reference and study alternative valid designs.
• Optionally invoke the review skill for mentor-style feedback: what you fixed, what you missed, and what new issues the refactor introduced.

Learning Design

The pedagogy is built around struggle first, answers second:

• AI assistance is instructed not to dump every violation immediately—guiding questions come before spoilers.
• Challenges span Intermediate difficulty across C#, Ruby, and Python, with optional hint comments on some problems and “discover it yourself” on others.
• Reference solutions and journey docs (including Mermaid before/after diagrams) reinforce the “why,” not just the rewrite.

Tech Stack

The Problem

Tokenbooks is a cryptocurrency accounting platform: automated transaction ingestion, cost-basis tracking, double-entry accounting across blockchain and exchange activity. None of that is useful to an accountant unless it can get into QuickBooks or Xero, the general ledgers finance teams actually run on. Syncing every transaction continuously would turn a detailed crypto subledger into a firehose the external provider was never built to absorb.

The Solution

I built the connectivity layer first: OAuth 2.0 integrations with QuickBooks Online and Xero, spanning the Next.js app, the NestJS backend, and a dedicated accounting-integrations microservice, with portfolio-scoped connection state so the right tenant stays attached to the right authorization through every redirect.

On top of that, I worked on a period-end posting system instead of continuous sync: close a period, deterministically compile the source journal entries into balanced external documents, generate a preview an accountant has to approve, then post asynchronously with duplicate protection and full traceability back to the original Tokenbooks transactions. Tokenbooks stays the detailed subledger; QuickBooks and Xero get a smaller, deterministic summary they can actually hold.

Finding the bottleneck

One part of that compilation step got slow once journal-entry volume grew. The usual story. I built a small benchmark harness to see where the time actually went, found it in a Prisma findMany pulling the full entry set into Node to aggregate, and replaced it with a single PostgreSQL GROUP BY so the database did the aggregation instead of the app. Same diagnostic habit as everything else on this site: don't guess at the slow part, trace it, then fix the actual cause.

Tech Stack

The Problem

Government data platforms carry a different kind of weight: who can see what, and whether you can prove it later. BioHub needed more reliable data-access workflows, clearer role-based permissions, and a traceable record of every access request, inside a self-serve portal built for submitting and managing public-sector data.

The Solution

I worked as an embedded full-stack developer on the Button Inc. team, building and refining features across the frontend, API, and routing layers, with test coverage built in rather than bolted on after. The focus was reliability: tighter role-based permissions, secure data-access workflows, and request traceability that holds up when someone asks who approved this, and when.

The Impact

A more reliable self-serve portal for managing data submissions, access requests, and the operational workflows around them, with fewer gaps between what the system allows and what it can actually account for.

Tech Stack