I'm a Software and Data Engineer at State Farm with a CS + Math dual-degree who loves building complex systems. I don't just "use" AI—I architect the pipelines, optimize the inference, and build the full-stack apps that wrap them.

Whether it's reverse-engineering mobile data networks, training GANs to design game levels, or building offline-first mobile apps, I'm obsessed with scalable architecture and clean code.

Collaborative finance at the speed of thought

Tech Stack: SwiftUI Convex Swift Clerk XcodeGen

A next-generation expense splitter engineered for zero friction. PayBack replaces clunky manual entry with a fluid, offline-first interface that syncs instantly. It treats shared finance as a real-time multiplayer experience, ensuring everyone stays settled up without the awkward math.

• Predictive Smart-Splits: Uses historical data and group context to intelligently suggest split percentages and categories, reducing entry time by 80%.
• Graph-Optimized Settlements: Minimizes payment cycles within complex groups using network flow algorithms, turning a web of debts into the fewest possible transactions.
• Transitive Identity Resolution: Implemented a transitive alias system (A->B->C) to merge "shadow members" (offline placeholders) into real user accounts when they sign up, preventing data fragmentation.

Tetris at the speed of light

Tech Stack: Rust WebAssembly WebGL TypeScript Rayon

A superhuman Tetris engine engineered in Rust. It doesn't just play; it solves the game. By combining a highly optimized SRS (Super Rotation System) implementation with a custom pathfinding algorithm, z-spin executes T-Spins and Perfect Clears at speeds no human can match.

• Kick-Table Pathfinding: Implemented a specialized A* search that treats the SRS kick table as a graph traversal problem. This allows the bot to "twist" pieces into impossible gaps by exploiting frame-perfect rotation mechanics that standard BFS would miss.
• Smart Mixed Strategies: The evaluation function isn't static; it dynamically switches between "Survival" (stack flat), "T-Spin Setup" (build overhangs), and "Downstack" (burn lines) modes based on the current garbage queue and board height.
• Rust Optimization: Leveraged Rust's zero-cost abstractions to implement bitwise collision detection that runs 100x faster than traditional object-oriented grids, allowing the bot to look ahead 10+ pieces in real-time.

Universal human verification via generative mini-games

Tech Stack: TypeScript Three.js Convex Next.js Woodwide AI LiveKit

A next-generation human verification system that replaces boring CAPTCHAs with interactive 3D mini-games. Instead of identifying traffic lights, Playproof monitors high-frequency behavioral telemetry—velocity, acceleration, and jerk—to distinguish humans from bots with 99.9% accuracy.

• Behavioral Anomaly Detection: Integrates Woodwide ML to analyze granular movement features (path efficiency, jitter) in real-time, catching bots that simulate human clicks but fail on micro-movements.
• Generative Game Engine: Dynamically constructs game scenes using chained LLM tool calls, ensuring every verification challenge is unique and immune to pre-trained computer vision attacks.
• Real-time Telemetry Streaming: Leverages LiveKit to stream behavioral data packets instantly to the scoring engine, allowing for sub-100ms verification decisions without adding friction.

Extending the AI engineer's OS

The core of my daily workflow. I maintain a suite of plugins for the OpenCode agent runtime.

Go-first runtime for deterministic tmux orchestration under load.

Tech Stack: Go TypeScript Tmux Connect RPC Protobuf Bun

OpenTmux is designed around a Go control plane with a TypeScript plugin shim for seamless OpenCode integration. This architecture provides predictable concurrency, low-overhead long-running process control, and portable static binaries that stay reliable under bursty session loads.

• Daemon + RPC Contract: opentmuxd exposes Init, OnSessionCreated, Stats, and Shutdown over a Unix socket using generated Connect/Protobuf bindings, with opentmuxctl as the control client and opentmux as the CLI wrapper.
• Deterministic Queueing & Cleanup: A high-throughput Go spawn queue handles retry/backoff, stale-work skipping, and in-flight duplicate coalescing, while session polling and a dedicated reaper clean idle panes and zombie opencode attach processes.
• Compatibility-First Interface: Public behavior stays stable through TypeScript shims (src/index.ts, src/bin/opentmux.ts), with Go test coverage for queue behavior, config normalization, and control service lifecycle.

Tech Stack: TypeScript Reverse Engineering Protobuf HTTP/2 SQLite

A custom authentication handler that bypasses the flaky standard login flow.

• Deep Reverse Engineering: Manually constructs binary Protobuf messages byte-by-byte to perfectly mimic the official Cursor client, including custom checksums and machine ID generation.
• Direct DB Access: Bypasses the keychain to read the encrypted accessToken directly from Cursor's internal state.vscdb SQLite database.
• Native HTTP/2: Implements a full duplex HTTP/2 client to stream tokens directly to the api2.cursor.sh endpoint, bypassing intermediate proxies.

Tech Stack: Semver Git CI/CD

A self-healing mechanism that allows the agent to update its own runtime code. It checks for upstream releases, resolves conflicts, and hot-reloads the plugin registry without restarting the session.

Tech Stack: Glow Go Markdown

⚠️ Note: Experimental. Incompatible with the standard OpenCode release; requires the custom Display Transform Hook fork.

Integrates Charm's Glow renderer to give the agent rich, syntax-highlighted markdown output in the terminal. It transforms raw text responses into beautiful, readable documentation.

Tech Stack: TypeScript React Ink Stream Transformers

A custom rendering engine engineered for high-frequency token streaming.

• The Hook: Intercepts the LLM's stdout stream and applies a custom "chunking" transform that batches tokens into 50ms render frames. This prevents React Ink from thrashing the TTY during high-speed generation (100+ tokens/sec).
• Status: Currently running in a private fork; preparing a Pull Request to merge this performance optimization into the core OpenCode runtime.

The computational chef that hallucinates deliciousness

Tech Stack: SwiftUI Django PyTorch CoreML Docker

A culinary AI that doesn't just scrape recipes—it invents them. By modeling flavor compounds as a high-dimensional vector space, TasteTinker creates novel gastronomic pairings that strictly adhere to molecular gastronomy principles.

• Molecular Flavor Graph: Built a knowledge graph of 50,000+ ingredients linked by shared volatile compounds, allowing the AI to suggest chemically-compatible but surprising pairings (e.g., White Chocolate & Caviar).
• Visual Pantry Analysis: Implemented a multi-modal RAG pipeline where users snap a photo of their fridge, and a vision transformer (ViT) segments ingredients to seed the generation context.
• Hybrid Inference Engine: Orchestrates a 7B parameter LLM for creativity and a constrained solver for nutrition/safety, ensuring recipes are edible while running sub-100ms on a T4 GPU.

Infinite Mario, generated by dreaming machines

Tech Stack: PyTorch Java WGAN-GP CMA-ES VGLC

A procedural content generation system that doesn't just stack blocks—it evolves them. By coupling a Wasserstein GAN with an evolutionary search algorithm (CMA-ES), MarioGAN discovers latent vectors that map to playable, high-difficulty levels that no human designed.

• Latent Variable Evolution (LVE): Instead of training an agent to build levels, I optimize the input noise vector of a frozen GAN using CMA-ES. This forces the generator to output levels that maximize a specific fitness function (e.g., "number of enemies").
• Playability Constraints: Integrated the Mario AI Framework (Java) as a fitness validator. Every generated level is simulation-tested by an A* agent; unplayable levels receive a fitness penalty, steering the evolutionary search back to valid manifolds.
• Style Transfer: The GAN was trained on the VGLC (Video Game Level Corpus), allowing it to interpolate between "Overworld" and "Underground" styles by traversing the latent space.

Wall Street-grade analysis, democratized

Tech Stack: Next.js Python TensorFlow Edgar-Tools Alpaca API

An institutional-grade financial intelligence platform. It doesn't just read news; it parses millions of SEC filings and cross-references them with real-time market data to find alpha that human analysts miss.

• Neural Market Forecasting: Implemented a recursive LSTM (Long Short-Term Memory) network that trains on 10+ years of OHLC data to predict 30-day price trends with surprisingly high conviction.
• Semantic SEC Parsing: Built a custom ingestion pipeline using edgar-tools that intelligently filters 10-Ks for high-signal sections (MD&A, Risk Factors) before feeding them into the context window, reducing noise by 90%.
• Whale Tracking: Real-time analysis of 13F filings to reverse-engineer the positions of major funds like Renaissance Technologies and BlackRock.

Pokemon Go, but for insurance claims

Tech Stack: Kotlin ARCore Jetpack Compose Firebase Google Maps

A geolocation-based AR game that gamifies the insurance inspection process. Users physically walk to geofenced locations to "capture" virtual hazards or assets overlayed on the real world.

• Clean Architecture: Migrated the legacy java codebase to a modern kotlin multi-module architecture, separating Domain, Data, and Presentation layers for testability.
• Geofence Service: Implemented a background broadcast receiver that triggers AR encounters only when the user enters a 15m radius of a target coordinate, optimizing battery life by keeping the camera off until needed.
• SceneView Integration: Replaced the deprecated Sceneform library with SceneView for rendering 3D assets, enabling high-fidelity PBR materials and shadows on Android devices.

Sketches to Comics, instantly

Tech Stack: Next.js Python Gemini Pro Stable Diffusion Flask

A generative AI pipeline that transforms rough storyboard sketches into fully rendered comic panels. It combines Gemini for narrative expansion with Stable Diffusion for visual rendering, automating the tedious parts of comic creation.

• Multi-Modal Pipeline: Orchestrates a two-step generation process: first, Gemini Pro expands a simple prompt into a detailed scene description, which is then fed into Stable Diffusion to generate the final panel.
• ControlNet Integration: Leverages the Dezgo API (Stable Diffusion ControlNet) to preserve the artist's original composition from the rough sketch while rendering high-fidelity details.
• Automated Storyboarding: Uses LLM-driven scene analysis to decompose a text script into optimal panel layouts and visual prompts.

Notion, but fast. Really fast

Tech Stack: Next.js 15 Lexical TypeScript Tailwind CSS Vercel

A collaborative, block-based editor designed for speed. Built on Meta's Lexical framework, it drops the heavy bloat of Electron apps for a pure web experience that loads in <50ms.

• Offline-First PWA: Engineered a robust Service Worker strategy that caches the entire editor runtime, allowing full functionality (create, edit, search) even when completely disconnected.
• Keyboard-Driven Workflow: Implemented a comprehensive command palette and shortcut system that allows power users to navigate and manipulate the document tree without ever touching the mouse.
• Zero-Layout Shift: A rewrite of the rendering engine using Next.js 15 Server Components to ensure the document layout is stable before the JavaScript bundle even hydrates.

"Talk is cheap. Show me the code." — Linus Torvalds