Nine systems, strongest first.

I built an agent that drives the whole ML lifecycle through a 12-tool MCP registry behind human approval gates, running every model-generated cell inside a hardened Docker sandbox with no network, a read-only rootfs, and a non-root user. The preprocessing path is a scaffold.

I built a multi-stage NLP smart-input pipeline (chrono-node, compromise, and a custom priority parser) that resolves overlapping parser claims by priority first, then per-tag confidence. The serverless path dropped Prisma for raw pg, while a parallel Express + Prisma stack still ships alongside it.

I wrote an MNIST MLP and hand-vectorized its hot paths with arch-dispatched AVX-512, AVX2, and NEON kernels over 64-byte-aligned, blocked-tiled matrices, no BLAS or PyTorch pulled in. OpenMP wins on big matrices and regresses small ones ~7x, so it is gated by size, not waved off.

I built a disk-backed relational engine end to end: SQL parser, cost-based optimizer, Volcano executors, MVCC with two-phase locking, and a WAL with ARIES recovery. It beats SQLite on batch inserts and loses on point selects by 2.0 to 2.6x.

I fine-tuned DeepSeek-Math 7B, paired it with FAISS retrieval over NaturalProofs and a SymPy tool registry, and drove it with an autonomous ReAct loop. The ablation ladder runs from 41.2% prompted to 77.6% with the full pipeline. Both figures are from results.sample.json, not a live GPU run.

I wrote 28 C++23 containers that self-host on each other the way a real standard library does: map on a red-black tree, lru-cache on list plus hash map. flat_map runs 0.378x of std::map. The tree map sits within 12 to 18% of std.

I wrote a C++23 expression language and compiled it to WebAssembly: tokenizer, recursive-descent parser, tree-walking evaluator, user functions, and recursion. It runs live in-browser on this project's own case page. It uses double everywhere with exact == comparisons, called out in the README.

I built one generic maze core, GenericMaze over a C++20 GraphCell concept, where each algorithm is a single templated method that drives both the headless solver and the live terminal animation. The callback copies the whole frontier each step, an O(n) cost taken on purpose for legibility.

I wrote a symbolic differentiation engine in pure Python with exact rational arithmetic and polynomial GCD, so derivatives stay exact instead of drifting to floats. The rational layer and GCD are hand-rolled rather than imported from fractions, the whole point and the cost of the project.