⠀⠠⠤⣤⣀⣀⣀⣠⡤⠴⠲⣶⡶⠤⠤⠤⢀⢀⣤⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⣿⣇⡒⠢⣤⢖⣹⠢⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⣼⣿⣿⠇⠀⠀⠀⠀⣿⣦⣠⣤⠂⠤⠤⠜⠛⠀⠀⠀⢠⡤⠤⣄⡤⠖⢊⣻⣀⣟⣸⠛⣿⡗⢾⣷⣶⠾⢿⣲⢄⠀⠀⠀⠀⠀⠀ ⠀⠀⢠⣿⣿⣇⣄⠦⣤⣀⣀⠀⠀⣀⣫⡗⠦⣀⠀⠀⠀⠀⠀⠀⠉⠐⢿⡶⠚⠭⠅⢉⣩⢵⣾⣿⣷⣿⣿⣉⣀⡀⠙⣿⣮⣰⣶⣶⠦⠤ ⠒⠠⠿⠿⢿⣻⣿⣆⠀⠉⢙⣻⣿⠿⣽⣶⠿⣞⣛⡒⠤⡄⣀⣤⡀⠀⠀⠀⠀⠀⠀⠀⠈⠑⢦⣏⠍⠉⣀⠉⠉⠛⠳⠞⢁⣿⣿⡏⠀⠀ ⠀⠀⠀⠀⠀⠀⠑⠬⣿⡶⠿⣿⣿⢲⡿⣧⣾⢉⣏⢹⡟⠛⢉⣽⣗⠠⣀⠀⠀⠀⢀⣤⠒⠒⠠⠝⠻⠿⣿⡇⠀⠀⠀⢀⣾⣿⣿⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠤⣟⣻⠾⠥⢤⣹⣿⣣⠞⠓⠉⠁⠀⠉⠙⠛⠀⠀⠀⠈⠛⠒⠂⠂⠒⠒⠒⠿⠷⠖⠒⠋⠉⠉⠙⠛⠧⢀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈
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:
SwiftUIConvexSwiftClerkXcodeGen
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:
RustWebAssemblyWebGLTypeScriptRayon
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.
Extending the AI engineer's OS.
The core of my daily workflow. I maintain a suite of plugins for the OpenCode agent runtime.
Tech Stack:
TypeScriptTmuxNode-ptyProcess Orchestration
A robust terminal manager that gives the agent persistent shell sessions.
- Session Management: Maintains a
Map<sessionId, TrackedSession>state machine to map agent sub-tasks to specific tmux panes. - Zombie Reaper: A background garbage collector that scans the process tree for orphaned
attachprocesses and kills them if the parent session is dead, preventing resource leaks. - Spawn Queue: Serializes pane creation with a mutex-like queue to prevent race conditions during parallel agent execution.
Tech Stack:
TypeScriptReverse EngineeringProtobufHTTP/2SQLite
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
accessTokendirectly from Cursor's internalstate.vscdbSQLite database. - Native HTTP/2: Implements a full duplex HTTP/2 client to stream tokens directly to the
api2.cursor.shendpoint, bypassing intermediate proxies.
Tech Stack:
SemverGitCI/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:
GlowGoMarkdown
⚠️ 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:
TypeScriptReact InkStream 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:
SwiftUIDjangoPyTorchCoreMLDocker
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:
PyTorchJavaWGAN-GPCMA-ESVGLC
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.jsPythonTensorFlowEdgar-ToolsAlpaca 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-toolsthat 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:
KotlinARCoreJetpack ComposeFirebaseGoogle 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
javacodebase to a modernkotlinmulti-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.jsPythonGemini ProStable DiffusionFlask
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 15LexicalTypeScriptTailwind CSSVercel
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
