The best software doesn't just run; it transforms. I am a Computer Engineer and aspiring AI/ML Engineer driven by a relentless curiosity for complex problem-solving, with a strong foundation in embedded systems and hardware architecture. My edge lies in my dual perspective: drawing on my Lean Six Sigma certification and leadership background, I approach technology not just as a developer, but as a process engineer. I pinpoint operational chaos and architect elegant, automated workflows in its place. From programming intelligent embedded devices to coding robust backends and financial engines, I channel my analytical rigor into creating the foundational data tools that empower the next generation of machine learning applications.

• Karel-Goes-to-Manila — Final Capstone Project for Stanford University's Code in Place (selected from 60,000+ applicants). An interactive 2D grid-based arcade Snake game built natively in Python (pygame-ce) featuring dynamic $25\times25+$ map expansion, infinite level scaling, procedural roadblocks, and persistent score tracking. (Verified Stanford Certificate)
• Orbital Feed - Automated posting powered by Generative AI under Javascript; niche-focused cross-posting across the digital platforms. (Private Repository — currently building the SaaS architecture for public release).
• NeuroBalance-Engine - A financial modeling system simulating and optimizing liability reduction strategies (Python, Flask). Built to handle complex resource allocation logic.
• Event_Horizon_JS - A dynamic data visualization dashboard utilizing NASA APIs (JavaScript, HTML, CSS).

• Living in the future: Actively researching and building tools to accelerate agentic engineering. My goal is to make autonomous AI agents more accessible by developing workflows that bridge the gap between complex LLMs and practical, everyday automation.
• Building intelligent systems: Transitioning deeply into AI/ML by tackling complex mathematical models in the AIMO Kaggle competition. I am actively applying advanced statistical concepts from my Stanford Probability for AI program to build more robust and predictable machine learning pipelines.
• Architecting efficiency: Merging my Lean Six Sigma background with software development. I don't just write scripts; I engineer tools designed to systematically eliminate real operational bottlenecks, drastically reduce cycle times, and optimize resource allocation across workflows.
• Rapid tool development & deployment: Spinning up scalable, functional applications—like workflow diagnostics and financial simulators—using Python, FastAPI, and React. I focus on taking ideas from raw prototypes to containerized, production-ready APIs with intuitive user interfaces.
• Translating hardware logic to software: Leveraging the structured, low-level thinking from my Computer Engineering and embedded systems background to write cleaner, faster, and highly efficient backend systems. I apply the same precision required for hardware configuration to optimize software performance in languages like Rust and Python.

• Stanford University: Probability for AI (October 2026)

  • Selected from over 20,000 applicants to participate in this specialized AI/ML probability course led by Stanford faculty.
  • Portfolio
    • A collection of interactive probabilistic simulations, machine learning models, and data tools built as part of Stanford University’s Probability for AI coursework (October–November 2026).

    Featured Projects

    • Word Detective
      • An interactive probability and text-analysis project built as part of Stanford's Probability for AI coursework. This app computes conditional probabilities to analyze linguistic patterns and distinguish between AI-generated and human-written text.

        How It Works

        1. Conditional Probability ($P(W|AI)$ vs $P(W|H)$):
           • Scans and compares word frequencies across AI responses versus human responses.
           • Calculates likelihood ratios to find which words are strongest indicators of machine-generated text (e.g., "super", "tiny", "imagine").
        2. Dataset & Corpus Processing:
           • Evaluates a dataset of paired prompts and responses across diverse everyday topics.
           • Computes empirical probability distributions to surface distinctive stylistic markers.

        Tech Stack

        • Interactive Web App Simulation: Custom probabilistic text-mining dashboard.
        • Core Concepts: Conditional probability, likelihood ratios, text analysis, and pattern recognition.
    • Inference Time Calculator
      • An interactive probability and scaling project built as part of Stanford's Probability for AI coursework. This app models how scaling inference-time compute (running multiple parallel model copies) dramatically increases the probability of successfully fixing complex software bugs.

        How It Works

        1. Probability of Independent Success ($P(F_i)$):
           • Evaluates the baseline success rate of a single model pass (such as DeepSeek-Coder-V2-Instruct achieving a 15.9% success rate on SWE-bench Lite).
        2. Complementary Probability & Failure Chains:
           • Calculates the joint probability that all copies fail simultaneously: $P(E^C) = (1 - P(F_i))^n$.
           • Derives the probability that at least one copy succeeds: $P(E) = 1 - (1 - P(F_i))^n$.
        3. Target Scaling & Batch Optimization:
           • Dynamically computes the minimum number of parallel model copies required to hit target confidence thresholds (e.g., 99.9% success probability).

        Tech Stack

        • Interactive Web App Simulation: Custom probability calculation and scaling playground.
        • Core Concepts: Independent events, complement probabilities, scaling laws, and inference-time compute optimization.
    • Medical Test Detective
      • An interactive Bayesian probability and diagnostic tool built as part of Stanford's Probability for AI coursework. This app visualizes how conditional probability works in real-world medical testing, helping users understand why false alarms happen even with highly accurate tests.

        How It Works

        1. Bayesian Inference & Conditional Probability:
           • Calculates the true probability of having a condition given a positive or negative test result using Bayes' theorem ($P(P|N^c)$ and related metrics).
           • Breaks down sensitivity ($P(N|P)$), false-positive rates ($P(N|P^c)$), and prior disease prevalence ($P(P)$).
        2. Natural Frequency Visualizations:
           • Translates abstract statistical percentages into intuitive frequencies out of 1,000 patients.
           • Illustrates the impact of base rate fallacies and common disease prevalences across different medical screenings.
        3. Dynamic Test Lookup:
           • Features pre-configured benchmarks (such as RT-PCR COVID-19 tests, Rapid HIV, strep, and prenatal cell-free DNA screenings).
           • Allows quick comparisons across different clinical contexts and demographics.

        Tech Stack

        • Interactive Web App Simulation: Custom probability visualization and Bayesian calculation engine.
        • Core Concepts: Bayes' Theorem, Conditional Probability, Medical Diagnostics, and Base Rate Fallacy.
    • Small Art Model
      • An interactive generative probabilistic art project built as part of Stanford's Probability for AI coursework. This app models a procedural story to paint fields of power-law distributed circles mimicking complex patterns.

        How It Works

        1. Generative Probabilistic Story: Defines a multi-step stochastic process for 400 circles, handling hidden latent variables ($S$, $A$, $W$, $G$, $B$) and observed data points ($R$, $C$, $P$).
        2. Parameter Tuning ($\theta$ weights):
           • Controls size distributions ($\theta_1$ to $\theta_3$), radius bands ($\theta_4$ to $\theta_6$), and color ink probabilities ($\theta_7$ to $\theta_9$).
           • Adjusts spatial variables like galactic concentration ($\theta_{11}$) and spiral arm tightness ($\theta_{10}$).
        3. Stochastic Rendering: Combines size weighting, arm choice, raw radius transforms, and angular jitter to generate randomized visual outputs on demand.

        Tech Stack

        • Interactive Web App Simulation: Custom probability-driven art generator.
        • Core Concepts: Generative models, probability distributions, latent variables, and parameter optimization.
    • The Hidden Chamber
      • An interactive probabilistic simulation and optimization project built as part of Stanford's Probability for AI coursework. This app models muon scattering physics to discover hidden chambers inside a pyramid without moving a single stone.

        How It Works

        1. Muon Counting & Poisson Processes: Analyzes minute-by-minute cosmic-ray muon arrivals beneath the pyramid, treating particle counts as a Poisson random variable.
        2. Maximum Likelihood Estimation (MLE):
           • Evaluates how likely a given stone thickness ($\theta_2$) is to produce the observed muon counts.
           • Computes log-likelihood scores to measure model fit against real archaeological scan scenarios.
        3. Gradient Ascent Optimization:
           • Uses iterative hill-climbing steps driven by score gradients to automatically adjust $\theta_2$ and pinpoint where the stone is thinner (revealing the hidden chamber).

        Tech Stack

        • Interactive Web App Simulation: Custom probability visualization and optimization playground.
        • Core Concepts: Maximum Likelihood, Poisson Distributions, Log-Likelihood Scoring, and Gradient Ascent.
    • Forest or farmland?
      • An interactive machine learning project built as part of Stanford's Probability for AI coursework. This app trains a logistic regression model from scratch using NumPy to classify satellite patches (Sentinel-2 data) into Forest versus Farmland.

        How It Works

        1. Feature Extraction: Analyzes satellite image patches across three main channels:
           • Dark Area (%): Measures canopy shading where treetops create darker regions.
           • Contrast (Standard Deviation): Captures variations between fields, hedges, and paths.
           • Greenness: Measures the spectral difference between green and red light.
        2. Logistic Regression & Gradient Ascent:
           • Uses a custom NumPy training loop over 3,104 training patches.
           • Optimizes weights ($\theta_0$ to $\theta_3$) using log-likelihood and gradient ascent.
        3. Generalization & Testing:
           • Evaluated against a locked 776-patch test set to prevent overfitting.
           • Tested on an unseen European map containing 100 aggregated patches.

        Tech Stack

        • Language: Python
        • Libraries: NumPy
        • Data Source: EuroSAT (Helber et al., 2019) with Copernicus Sentinel data.
    • Planet Hunters - An interactive probabilistic machine learning project built as part of Stanford's Probability for AI coursework. This app processes real Kepler space telescope data to classify brightness dips and calculate the probability that an astronomical signal is an exoplanet. #### How It Works 1. Feature Extraction & Normalization: Analyzes over 6,100 Kepler dips using key features: - Size ($x_1$): Estimated radius in Earth masses. - Other Dips ($x_2$): Count of sibling dips around the same star (planets often form families). - V-Shaped Dip ($x_3$): Indicator of stellar eclipses versus flat-bottomed planetary transits. - Repeat Speed ($x_4$): Fast recurrence under 3 days (common in close binary stars). 2. Logistic Regression & Gradient Ascent: - Uses a custom NumPy training loop over 4,954 training dips. - Optimizes weights ($\theta_0$ to $\theta_4$) via log-likelihood ascent to separate true exoplanets from false positives. 3. Generalization & Validation: - Tested against a locked 1,238-dip test set to ensure robust performance on unseen space data. - Evaluated against historical telescope validation data (Valizadegan et al., Armstrong et al.) to rank top candidate targets. #### Tech Stack * Language: Python * Libraries: NumPy * Data Source: NASA Kepler Mission / Exoplanet Archive

• Stanford University: Code in Place (June 2026)

  • Completed Stanford's rigorous introductory Python programming course.

  • Final Project Highlight: Karel-Goes-to-Manila – An extended 2D simulation environment developed in Python, where Karel navigates traffic, manages battery resources, and handles urban delivery routing through the streets of Metro Manila.

• Lean Six Sigma Yellow Belt

"Hardware taught me the constraints. Software gives me the scale. Logic and efficiency dictate how I build."