I pulled a dead 2013 Butterfly Labs "Jalapeno" SHA-256 mining ASIC out of a drawer and built a modern Python toolkit for it. Then I hit the wall every honest hardware project should.
I "found" undocumented serial commands the mining software (cgminer) defines but never sends, including a persistent NVRAM scratchpad that survives power cycles. I wrote my name and the repo URL into the silicon; it's still there.
Then I checked prior art. All of it is in Butterfly Labs' own 2012 protocol spec and their open source firmware. Rederivation, not discovery. I even almost filed a "bug" against cgminer before a last look at its code showed it was right and I'd misread it. Twice, the "gotcha" was me not reading carefully.
Why it was still worth it, the firmware source can't tell you the chip still works. So I measured it, model free:
1. Four hours of continuous work, zero compute errors, fully deterministic. 2. The winning nonce count is Poisson(~1), the chip scans the whole 2^32 nonce space per job. 3. Thermally over built: it won't error even with the fan off (~41C max on a desk).
The one genuinely new thing: a dead-core detector. It flags a dead engine as a cold band in the nonce histogram. It can't map the healthy engine partitions (they sum to uniform), only localize the dead ones.
The honest move, go check whether it's already known, costs you a discovery and gives you the truth. Better trade every time.
A dead 2013 Butterfly Labs "Jalapeno" SHA-256 mining ASIC sat in a drawer for a decade. It became the excuse for a small, careful question: how much structure can a tiny, cheap model learn in SHA-256, and how would I know if I were fooling myself? (The ML runs on CPU and a HF job, not the ASIC; the dead miner is just the origin story.)
Three findings, written up honestly:
1. A sharp round-4 cliff. Round-reduced SHA-256 is ~100% distinguishable through 3 rounds, then collapses to chance at round 4 and stays there out to the full 64. Reproduced across 5 seeds.
2. A controls-gated bounded null on full SHA-256: no learnable structure above a ~0.22% resolution floor at n=4,000,000. That is a bounded null at this budget, not a claim that SHA-256 is random.
3. A "signal" in the iterated-hash dynamics that a permuted-label control unmasked as a label-prior artifact. The instrument caught its own false positive. That was the point of building the controls.
Negative results, stated with their resolution. The dataset carries the controls on every row.
Scored 0.390/0.409 on the Vesuvius Challenge Surface Detection — the 1st place team hit 0.614 with nnU-Net. That gap sent us down a rabbit hole.
We built four independent 3D segmentation pipelines to understand what actually matters: standard U-Net, deep supervision + focal loss, multi-scale fusion, and finally nnU-Net itself. Each pipeline taught us something — V1 showed us our GPU was idle 90% of the time (CPU feature bottleneck), V2 proved skeleton recall beats clDice, V3 NaN'd at epoch 55 from FP16 overflow, and nnU-Net is training on HF Jobs right now.
The 1st place post-processing pipeline (binary closing, height-map patching, LUT hole plugging) turned out to be a bigger lever than we expected. We only had access after the competition closed and writeups were published.
Built an agentic Clinical Decision Support system powered by MedGemma 27B
Paste a patient case → get a full clinical decision support report with differential diagnoses, drug interaction checks (via real OpenFDA/RxNorm APIs), guideline recommendations from a 62-guideline RAG corpus, and automated care gap detection.
6-step agentic pipeline, all streaming in real time:
Parse free-text → structured patient data Clinical reasoning → ranked differential diagnosis Drug interaction check → real FDA database queries Guideline retrieval → RAG over 14 medical specialties Conflict detection → gaps between guidelines and patient care Synthesis → comprehensive CDS report Built with MedGemma 27B, FastAPI, ChromaDB, Next.js. No LangChain — custom orchestrator throughout.
