Systems work, with the decisions left in.

• Designed and delivered 50+ software-engineering evaluations for frontier AI coding models, each with a deterministic reference solution and automated grading.
• Reviewed 200+ evaluations for correctness, test coverage, reproducibility, and resistance to reward hacking.
• Strengthened model-assessment signal by applying AI-assisted code review and systematic failure analysis.

Evaluating whether a frontier model can actually ship working code requires tasks that are unambiguous, reproducible, and impossible to game. Weak specs, flaky tests, or exploitable graders produce misleading scores that overstate model capability.

1. Authored deterministic reference solutions and pytest grading harnesses for each task.
2. Packaged every evaluation in a reproducible container so results are environment-independent.
3. Designed anti-cheat validation to catch reward hacking and shortcut solutions.
4. Reviewed peers' evaluations for verifier strength, instruction/test alignment, and reproducibility.
5. Used AI-assisted code review and failure analysis to raise task quality and code quality.

• 50+ evaluations delivered with deterministic grading and anti-cheat validation.
• 200+ evaluations reviewed, improving correctness, coverage, and reproducibility across the set.
• Clearer, harder-to-game tasks that produce more trustworthy model-capability signal.

• Enabled bi-directional live sync between Snowflake and Ping Advanced Identity Cloud for 250,000+ student and staff identities.
• Replaced legacy IAM, unlocking LAUSD’s migration to modern cloud identity at district scale.
• Improved reliability and reduced operational overhead from nightly manual reconciliations.

Snowflake write operations were failing during identity syncs because the ForgeRock Database Table Connector incorrectly attempted `RETURN_GENERATED_KEYS` on non-INSERT operations. Since Snowflake views are immutable, deletes/updates failed, blocking the migration and stalling LAUSD’s IAM modernization.

1. Diagnosed connector’s JDBC misuse (`RETURN_GENERATED_KEYS` on DELETE/PATCH).
2. Patched ForgeRock Database Table Connector to skip unsupported calls.
3. Designed and deployed live sync so that identity changes in Snowflake automatically propagated to Ping AIC—and vice versa.
4. Validated integration with test cohorts; rolled out incrementally to 250K users.
5. Implemented monitoring and alerting for sync reliability.

• Migration unblocked; Snowflake ↔ Ping AIC synchronization stable in production.
• LAUSD successfully cut over from legacy IAM, covering quarter-million identities.
• Reduced sync failures to near-zero; eliminated manual reconciliation overhead.

• Modernized docket notice pipeline to Kotlin with stricter contracts and versioned REST.
• Produced deterministic PDF notices via Freemarker + FlyingSaucer replacement, improving reliability and debuggability.

Legacy Java utilities and Velocity templates caused brittle formatting and null-handling issues in docket data.

1. Ported Java to Kotlin with data classes; enforced enums and date formatting in DocketNoticeData.
2. Replaced Velocity with Freemarker; added safe URL escaping via String?.escapeUrlString().
3. Fixed ResultSet mapping, null safety, and associated-case queries.
4. Added tests around getAssociateCaseView; stabilized template rendering.

• Eliminated classes of null and formatting errors; predictable PDFs and simpler diffs.
• Clearer API boundaries and easier future changes.

• Created a Docker Compose test rig for eDirectory with init imports and cert generation, enabling consistent IdMUnit runs in CI.
• Reduced flaky start and wait issues with a dynamic readiness gate instead of hardcoded sleeps.

Manual setup of directory state and TLS blocked reliable automated tests and slowed builds.

1. Four-service Compose: cert-generator, eDir, eDir-init, test-runner.
2. Dynamic wait for TLS port and health checks before tests.
3. Jenkins pipeline with stages for container startup, AD↔eDir network verification, and Ant build.
4. Host-network config for Maven stages; artifact gating for snapshot and release.

• Reproducible local and CI environment; fewer flakes and faster feedback loops.
• Clear runbook and predictable test outcomes.

• Built, tested, and deployed a production Ruby/Fluentd pipeline that transformed a high volume of Ping Advanced Identity Cloud login and logout events into structured Verafin fraud-monitoring records.
• Delivered a single, normalized record shape that fraud and AML workflows could consume reliably.
• Hardened the pipeline against real production failure modes so ingestion stayed dependable.

Raw Ping authentication logs did not match Verafin's required schema, and a naive transform broke on malformed fields, missing values, and delimiter collisions—stalling fraud and AML monitoring for a credit union's login activity.

1. Implemented event mapping and field normalization in Fluentd using Ruby filters.
2. Added resilient field fallbacks, status normalization, and delimiter-safe serialization to survive malformed input.
3. Diagnosed and fixed control-flow, nil-response, and runtime failures surfaced in production.
4. Added local diagnostic logging and validated output against the Verafin specification.

• Auditable, compliant ingestion with a single normalized record shape.
• Eliminated manual reconciliation by enforcing consistent, well-formed records.
• Improved production reliability by removing the control-flow and nil-response failure modes.

• Built Python pipelines on Azure HPC clusters to analyze GPU thermal and telemetry data used for model training and tuning cycles.
• Automated access-review compliance workflows, processing 50K+ records and surfacing insights via dashboards.

Telemetry was scattered and manual compliance processing slowed operations.

1. Orchestrated Python jobs on Azure and stored and queried data in Azure Data Explorer.
2. Automated access-review workflows with Logic Apps and standardized the data shape.
3. Published interactive dashboards for stakeholders.

• Faster tuning feedback for HPC users and reduced manual compliance effort.
• Centralized data with repeatable workflows.