I'm a security-minded backend developer. Most of what I build lives on a trust boundary — a proxy forwarding data it never inspected, an admin panel believing a value straight from the browser — and most of what I fix upstream starts the same way: I reproduce the bug first, then write the test that proves it.

I co-founded and lead the backend at NoMansAi (Node.js, Express, Redis, n8n), and I spend the rest of my time finding real bugs in code that millions of people depend on.

14 pull requests merged into projects with 395,000+ combined stars. Each one addresses a behavioural bug and includes regression coverage.

I fixed the actions/unpinned-tag query trusting floating tags like @v4 on "immutable" Actions. Only full versions and commit SHAs are actually immutable — floating tags get moved — so the query now flags the rest. #22630, fixing #22414.

I found CIFuzz writing its SARIF report from whatever the last fuzz target returned. In batch mode a crash found by any earlier target failed the build but reached GitHub code scanning as an empty report — a silently missed finding. #16170.

_{C# · 59k ⭐}

I found an episode-name regex that never finishes on file names carrying several bracketed tags, which stalls the library scan they are part of: 53 characters took 29 seconds, and the cost tripled with every two tags. I tried four rewrites and kept the only one that matched the original on 300,000 random names. #18420.

_{Kotlin · 25k ⭐}

I found a crash that stopped a manga from refreshing when a chapter name held a #: names were grouped by masking their numbers with that same character, so a group was indexed past the end of its shortest member. #4107.

Most of these weren't reported by anyone. I went looking.

Differential fuzzing — I run reference implementations against the real ones on random inputs. That's how I found the interpolationSearch infinite loop and a linked-list corruption in trekhleb/javascript-algorithms (196k ⭐).

Measuring, not guessing — for the DevSkim ReDoS I timed the real .NET engine rather than trusting a Python regex model that over-reported it. The same habit found marked (37k ⭐) taking 16 seconds on 12 KB of unmatched emphasis markers; I reported it with the numbers, and the fix shipped in v18.1.3.

Cross-platform reproduction — I work on Windows, so I catch what Linux-only CI never runs: a TypeScript path-separator bug in styled-components and a missing audio codec in Manim, both merged, a libuv teardown crash in Playwright, and a packaging path that ships py.typed with no stubs in Gradio.

_{Python · research prototype}

A quiet feed is not the same as a quiet world.

I built a probabilistic conflict forecaster around one problem most forecasting systems ignore: event data arrives late and gets revised, so a month that looks quiet may only look quiet because the reports haven't come in yet. AEGIS estimates how complete the recent record probably is, forecasts with that in mind, and can answer ABSTAIN instead of producing a number it can't stand behind.

It keeps every data release as an immutable, hashed vintage and backtests each forecast only against what existed at the time. It ships a terminal interface and a 3D globe down to 1,367 provinces. The interface always shows the simple baseline's score next to its own — and I publish that the baseline still wins on one of the two metrics, because a forecaster that hides its misses isn't one.

_{TypeScript · in development}

I'm building an SDK for scope-aware video editing: click an object and edit only that object. Move, resize, recolour or remove it in the browser, and what was behind it is rebuilt from other frames. Selections are tracked through the clip, and frames where the tracker loses the object are flagged instead of silently edited.

The guarantee I care about is tested rather than promised: pixels outside the selection stay byte-identical, even when an AI model produced the edit. The README lists what doesn't work yet as plainly as what does.

I built a local, zero-trust LLM proxy. Point an OpenAI SDK, LangChain or any HTTP client at localhost:8000/v1 instead of the provider, and every request gets PII-scrubbed, cost-tracked, rate-limited and cached — streaming included — whether it's headed to OpenAI, Anthropic, Gemini or a local Ollama model.

The part I care most about is the sanitizer: reversible placeholders, Luhn-validated card detection and structurally-validated SSNs, so it redacts without mangling order numbers. Nothing leaves the machine except the sanitized request.

Looking for backend or security engineering work. The fastest way to judge me is the pull request list above — open any one of them.