Show HN for January 5, 2026

Why - I got sick of apps abusing notifications on my Android phone. While the OS does give you the ability to switch off notifications based on channels, most apps either don't use it or abuse it intentionally. In my case, I live in a gated society that uses an app called MyGate to allow visitors, and the app intentionally pushes ads through the same channels since you cannot block them.

What - DoNotNotify is an app that logs all incoming notifications, and displays them grouped by app. It also captures the action behind the notification, which can be triggered from the app itself. From this log, you can create rules to whitelist/blacklist notifications from apps depending on their notification content. These filters can even be regex expressions, which allows for more complicated use-cases. The app ships with some pre-defined rules for popular apps like Facebook, Amazon, Instagram, Netflix, TikTok, Reddit etc.

Where - The website is at https://donotnotify.com/.

Would also like to call out that the app runs purely on your device, never communicates with anything on the Internet, and only requires notifications access to work. It is completely free, and there is no advertising or hidden gotchas.

Hi HN,

I’m a former C++ dev turned Product Manager.

I’ve noticed many engineers struggle with the "politics" side of things when they become Leads. To help with this, I’m building a text-based simulator.

It is NOT an AI chatbot. It is a hand-crafted, branching narrative (logic tree) based on real experiences.

I just launched the first scenario: "The Backchannel VP."

The Setup: Your VP Engineering is bypassing you and giving tasks directly to your juniors, causing chaos.

Your Goal: Stop the backchanneling without getting fired.

It’s a short, specific puzzle. I’d love to know if you think the "Correct" path I designed matches your real-world experience, or if I’m off base.

Link: https://apmcommunication.com/scenario/backchannel-vp

I created a small webapp, to create simple audio loops online. A bit rough around the edges but gets you started in less than 10 seconds on creating loops.

Hi HN, I recently shared this on r/BCI and wanted to see what the engineering community here thinks.

A while back, I got frustrated with the state of accessible BCI hardware. Research gear was wildly unaffordable. So, I spent a ton of time designing a custom board, software and firmware to bridge that gap. I call it the Cerelog ESP-EEG. It is open-source (Firmware + Schematics), and I designed it specifically to fix the signal integrity issues found in most DIY hardware.

I believe in sharing the work. You can find the Schematics, Firmware, and Software setup on the GitHub repo: GITHUB LINK: https://github.com/Cerelog-ESP-EEG/ESP-EEG

For those who don't want to deal with BGA soldering or sourcing components, I do have assembled units available: https://www.cerelog.com/eeg_researchers.html

THE MAJOR FEATURES: Forked/modified OpenBCI GUI Compatibility as well as Brainflow API, and LSL Compatibility

I know a lot of us rely on the OpenBCI GUI for visualization because it just works. I didn't want to reinvent the wheel, so I ensured this board supports it natively.

IT WORKS OUT-OF-THE-BOX: I maintain a forked modified version of the GUI that connects to the board via LSL (Lab Streaming Layer). ZERO CODING REQUIRED: You can visualize FFTs, Spectrograms, and EMG widgets immediately without writing a single line of Python.

THE "ACTIVE BIAS" (WHY MY SIGNAL IS CLEANER) The TI ADS1299 is the gold standard for EEG, but many dev boards implement it incorrectly. They often leave the Bias feedback loop "open" (passive), which makes them terrible at rejecting 60Hz mains hum. I simply followed the datasheet: I implemented a True Closed-Loop Active Bias (Drive Right Leg). HOW IT WORKS: It measures the common-mode signal, inverts it, and actively drives it back into the body. THE RESULT: Cleaner data

THE TECH STACK:

ADC: TI ADS1299 (24-bit, 8-channel).

MCU: ESP32 Chosen to handle high-speed SPI and WiFi/USB streaming

SOFTWARE: BrainFlow support (Python, C++, Java, C#) for those who want to build custom ML pipelines, LSL support, and forked version of OpenBCI GUI support

This was a huge project for me. I’m happy to geek out about getting the ESP32 to stream reliably at high sample rates as both the software and firmware for this project proved a lot more challenging than I expected. Let me know what you think!

-- REVIEWS: If you want an independent look at the specs, CNX Software and Hackster just wrote about the board here:

https://www.cnx-software.com/2025/12/26/cerelog-esp-eeg-a-lo...

And here

https://www.hackster.io/news/this-open-source-eeg-board-brin...

SAFETY NOTE: I strongly recommend running this on a LiPo battery via WiFi. If you must use USB, please use a laptop running on battery power, not plugged into the wall.

I built an open labeling standard for tracking mushroom specimens through their lifecycle (from spore/culture to harvest).

v1.1 adds clonal generation tracking (distinct from filial/strain generations) and conforms to JSON-LD for interoperability with agricultural/scientific data systems.

Spec (CC 4.0): https://wemush.com/open-standard/specification Client libraries (Apache 2.0): Python + CLI: pip install wols (also on GHCR) TypeScript/JS: npm install @wemush/wols

Background: Mycology has fragmented data practices (misidentified species, inconsistent cultivation logs, no shared vocabulary for tracking genetics across generations). This is an attempt to fix that.

Looking for feedback from anyone working with biological specimen tracking, agricultural data systems, or mycology.

Hi HN, I made OSS Sustain Guard.

After every high-profile OSS incident, I wonder about the packages I rely on right now. I can skim issues/PRs and activity on GitHub, but that doesn’t scale when you have tens or hundreds of dependencies. I built this to surface sustainability signals (maintainer redundancy, activity trends, funding links, etc.) and create awareness. It’s meant to start a respectful conversation, not to judge projects. These are signals, not truth; everything is inferred from public data (internal mirrors/private work won’t show up).

Quick start: pip install oss-sustain-guard export GITHUB_TOKEN=... os4g check

It uses GitHub GraphQL with local caching (no telemetry; token not uploaded/stored), and supports multiple ecosystems (Python/JS/Rust/Go/Java/etc.).

Repo: https://github.com/onukura/oss-sustain-guard

I’d love feedback on metric choices/thresholds and wording that stays respectful. If you have examples where these signals break down, please share.

I really like the look of the famous album art for Unknown Pleasures [1]. It was originally created by Harold Craft at the Arecibo Observatory from the signals of the first discovered radio pulsar [2].

I made a spectrogram that produces a similar look. It runs FFT in Rust and visualizes it with WebGL.

[1]: https://en.wikipedia.org/wiki/File:UnknownPleasuresVinyl.jpg

[2]: https://en.wikipedia.org/wiki/PSR_B1919%2B21

Hi HN, Bhavani here (rtrvr.ai).

We build DOM-native web agents (no screenshot-based vision, no CDP/Playwright debugger-port control). We handle captchas natively including Google reCAPTCHA image challenges by traversing cross-origin iframes and shadow DOM. The latency is high on this one currently.

The problem: when debugging image selection captchas ("select all images with traffic lights"), logs don't tell you why the agent clicked the wrong tiles. I found myself staring at execution logs thinking "did it even see the grid correctly?" and realized I just wanted to watch it work.

So we built live VNC view + takeover for serverless Chrome workers on Cloud Run.

Key learnings:

1. Session affinity is best-effort; "attach later" can hit a different instance

2. A separate relay service that pairs viewer↔runner by short-lived tokens makes attach deterministic

3. Runner stays clean: concurrency=1, one browser per container, no mixed traffic

Would love feedback from folks who've shipped similar:

1. What replaced VNC for you (WebRTC etc) and why?

2. Best approach for recording/replay without huge storage?

3. How do you handle "attach later" safely in serverless?

I’ve been tinkering with what a “multi-agent IDE” should look like if your day-to-day workflow is mostly in terminal (Claude Code, OpenAI Codex, etc.). The more I played with it, the more it collapsed into three fundamentals:

* A good TUI: Terminal is the center stage, with other stuff (CodeEdit, Diff, Review) baked on the side. I don’t like piping Agent’s output through some electron wrapper, here you get to run CC/Codex/Droid/Amp/etc directly.

* Isolation: agents shouldn’t step on each other’s toes. The simplest primitive I’ve found is Git worktrees. It is not as isolated nor heavy as containers/vms, but it is the next best thing for working locally. Each agent gets its own working directory and their own snapshot of the repo. Git worktree requires CLI kung-fu, but agentastic simplifies it through some nice GUI and keyboard shortcuts for easy creation/switching/etc.

* An excellent terminal: I couldn’t get comfortable with xterm.js (Code/Cursor/Conductor/etc), and i loved Ghostty, it is fast, pretty, and feels right. So naturally the whole experience is built around Ghostty (There is also SwiftTerm as an alternative option).

Agentastic.dev is a native mac IDE, built around the workflow of “one task = one worktree = one terminal session” as the default. You spin up multiple worktrees (branches) and run different agents in parallel, each with its own clean working directory and terminal session and codeedit, then review and merge when you’re ready.

We’ve been dogfooding it to build http://agentastic.dev itself and agentastic.com (coming soon), and it’s noticeably improved our productivity. https://pasteboard.co/xg1YOsk5MIn9.png

It’s early and still rough in places. I’d love feedback from people who use worktrees heavily or run multiple coding agents:

- What would you want from a multi-agent IDE that you can’t get from a terminal + tmux?

- What’s missing / annoying in your current worktree workflow?

Background: I’ve spent the last few years writing Logos of Aether (500+ pages, open source), which attempts to derive the Standard Model using a monadic, cellular-automata approach rather than standard continuous calculus.

The Core Idea: Modern physics breaks down at singularities because our math allows for infinite density (division by zero). I replaced standard addition with "Plenum Addition" (⊕), a saturating operation similar to velocity addition in Special Relativity, but applied to information density.

The Math: Instead of linear addition (1+1=2), distinctions add via: x ⊕ y = (x + y) / (1 + xy/π²)

This forces a hard ceiling on information density (π), naturally eliminating black hole singularities and "infinite energy" bugs in QFT without needing renormalization.

Why I'm posting: I have the theoretical derivation (including a geometric derivation of the Electron Mass as an 11th harmonic resonance), but I am moving from "Paper" to "Engine." I am looking for contributors interested in Cellular Automata and Python/JAX to help build the reference simulation ("The Rattle") to test these interactions in a grid.

The book is Public Domain. I’m not selling anything. Just trying to see if this codebase runs universe-v1.0 correctly.

AMA about the "Teeter-Totter Principle" or the derivation logic.

Hi HN,

This is a small RISC-V emulator I’ve been hacking on in Emacs Lisp as a fun weekend project.

It started mostly as a way to better understand the RISC-V spec by implementing things myself, and also as an excuse to write more non-trivial Emacs Lisp. It currently focuses on RV32I and related basics, and is very much not optimized or production-ready.

If you’re into RISC-V, emulators, or just enjoy seeing unusual things built in Emacs Lisp, feedback and comments are welcome

Happy hacking!

Hey, I built Debut because I wanted Screen Studio's polish without the price tag. It does smooth cursor animations, automatic zoom effects, and clean exports: basically the stuff that makes screen recordings look professional without hours in a video editor. $25 lifetime for personal use, works on 2 devices. Would love feedback, especially from anyone who's tried Screen Studio or other recording tools and found them lacking.

Hello everybody,

I built Memory Graph to help students (and myself) build a correct mental model of Python references, mutability, and copying, and to make debugging data structures less “print-driven”. It’s inspired by Python Tutor, but focuses on clearer graphs and on running locally in many different environments and debuggers. The Memory Graph Web Debugger quickly turns your web browser into a Python debugger where the whole program state is visualized in each step, clearly showing aliasing and the structure of the data, giving insight that is hard to get with just printing.

Some interesting examples:

- Recursion, decimal to binary conversion: https://memory-graph.com/#codeurl=https://raw.githubusercont...

- Binary Tree data structure: https://memory-graph.com/#codeurl=https://raw.githubusercont...

- Cocktail Shaker Sort: https://memory-graph.com/#codeurl=https://raw.githubusercont...

Here you can find some difficult Python Data Model exercises for use in education where Memory Graph helps explain the correct answer:

  https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md

created Crystalline Protocol. It treats the blockchain state not just as a key-value store, but as a mathematical set governed by the Axioms of Zermelo-Fraenkel set theory.

The PoC (written in Rust) demonstrates an "Axiomatic Engine" that enforces the Axiom of Regularity. It physically prevents circular dependencies (logical loops) at the VM level. If a transaction creates a cycle, the "Logic Firewall" rejects it before it can ever be executed.

Hi everyone,

I’ve been working on an open-source tool called Flakestorm to test the reliability of AI agents before they hit production.

Most agent testing today focuses on eval scores or happy-path prompts. In practice, agents tend to fail in more mundane ways: typos, tone shifts, long context, malformed input, or simple prompt injections — especially when running on smaller or local models. Flakestorm applies chaos-engineering ideas to agents. Instead of testing one prompt, it takes a “golden prompt”, generates adversarial mutations (semantic variations, noise, injections, encoding edge cases), runs them against your agent, and produces a robustness score plus a detailed HTML report showing what broke.

Key points: Local-first (uses Ollama for mutation generation)

Tested with Qwen / Gemma / other small models Works against HTTP agents, LangChain chains, or Python callables No cloud or API keys required This started as a way to debug my own agents after seeing them behave unpredictably under real user input. I’m still early and trying to understand how useful this is outside my own workflow.

I’d really appreciate feedback on: Whether this overlaps with how you test agents today Failure modes you’ve seen that aren’t covered Whether “chaos testing for agents” is a useful framing, or if this should be thought of differently Repo: https://github.com/flakestorm/flakestorm Docs are admittedly long.

Thanks for taking a look.

I built Living Memory Dynamics (LMD), a Python framework for simulating biologically-inspired "living" episodic memory directly in embedding space—no external LLM required for the core dynamics. Memories evolve over time like living entities: they have metabolic energy states (vivid → active → dormant → fading → ghost), emotional trajectories, and resonance fields that let them influence each other. The central piece is a new differential equation I derived (the Joshua R. Thomas Memory Equation) that drives continuous-time evolution: dM/dt = ∇φ(N) + Σⱼ Γᵢⱼ R(vᵢ, vⱼ) + A(M, ξ) + κη(t) This enables emergent behaviors: automatic narrative arcs (setup → conflict → climax → resolution), creative leaps via four operators (analogical transfer, manifold walking, orthogonal composition, void extrapolation), and hierarchical idea grafting. Key points:

Pure vector operations (PyTorch + optional Triton CUDA kernels for speed) Optional lightweight language grounding with sentence-transformers Pip installable: pip install living-memory-dynamics (extras for language/cuda/all) Benchmarks on consumer hardware show real-time evolution for dozens of memories

It's very new (released yesterday), and I'm submitting to arXiv soon (waiting on endorsement). Full research paper and math in the repo docs. Would love feedback—try the examples and let me know what kinds of narratives or ideas it generates for you! GitHub: https://github.com/mordiaky/LMD PyPI: https://pypi.org/project/living-memory-dynamics/

OP here. I built RepoReaper to solve code context fragmentation in RAG.

Unlike standard chat-with-repo tools, it simulates a senior engineer's workflow: it parses Python AST for logic-aware chunking, uses a ReAct loop to JIT-fetch missing file dependencies from GitHub, and employs hybrid search (BM25+Vector). It also generates Mermaid diagrams for architecture visualization. The backend is fully async and persists state via ChromaDB.

Link: https://github.com/tzzp1224/RepoReaper

We've all been there: You find an unused NAT Gateway costing $45/mo. You delete it in the AWS console to stop the billing immediately. But the next time you run terraform plan, it fails because of state drift. Now you have to manually run terraform state rm or import it back to fix the drift. It's tedious, so often we just leave the waste running. I built CloudSlash to automate the cleanup and the state surgery. It’s written in Go (using BubbleTea for the TUI) and solves two engineering problems: 1. Finding "hollow" resources (the graph). Most cost tools just check CloudWatch metrics (CPU < 5%). That creates too much noise. Instead, I build an in-memory graph of the infrastructure to find structural waste. Example: An "Active" ELB. It has healthy targets, so metrics look good. But if you traverse the graph (ELB -> Instance -> Subnet -> Route Table), you might see the Route Table has no path to an Internet Gateway. The ELB is functionally dead, even if AWS reports it as "healthy." 2. The state mapping. Deleting the resource in AWS is easy. The challenge is mapping a physical ID (e.g., nat-0a1b2c) back to its Terraform address (e.g., module.vpc.aws_nat_gateway.public[0]) so you can remove it from the state file programmatically. I wrote a parser that reads your local .tfstate, handles the complex JSON structure (including nested modules and for_each outputs), and generates a remediation script. It outputs a shell script (fix_terraform.sh) that runs the necessary terraform state rm commands for you. It never writes to your .tf files directly—it just hands you the script to review and run. The core logic, scanner, and TUI are open source (AGPLv3). I charge a one-time license for the feature that auto-generates the fix scripts for developers , but the forensic analysis/detection is free. Repo: https://github.com/DrSkyle/CloudSlash

Hi HN!

I'd like to share my app for viewing images the way I find comfortable on a desktop computer. No window frame, no menus, no toolbars, just the image itself in transparent fullscreen overlay; pan (move around) with mouse with left button pressed (or keyboard arrows), zoom into point under cursor with scroll (or into point at center of display with keyboard +=/-/0), close with left click anywhere (or keyboard Enter, allowing "instant toggle" between file manager and image view). Written in C and Rust with SDL3 and image-rs.

Source and builds for Linux (Ubuntu 25.10, Nix expr) and Windows: https://github.com/shatsky/lightning-image-viewer

Microsoft store (with screenshot): https://apps.microsoft.com/detail/9np4j8k90smk

Web demo: https://shatsky.github.io/lightning-image-viewer/

Dev notes: https://shatsky.github.io/notes/2025-03-07_sdl3-image-viewer...

Hi HN!

I'm one of the people building ONYX Data Rooms.

We started working on this during our own fundraise and noticed that many data rooms focus on later-stage fundraising processes and budgets, rather than the needs of early- and growth-stage founders.

What stood out to us the most wasn't the lack of data, but the lack of clarity. As founders, we could see that documents were being opened, but it was hard to understand: - which investors are genuinely engaged vs. just clicking through - which documents are getting attention vs. being skipped - where diligence is slowing down or generating questions

ONYX focuses on making that clearer: - unlimited data rooms and users - analytics that highlight which investors are active and which documents are being read - built-in Q&A so questions stay connected to the relevant files

The goal isn't to add more metrics, but to help founders prioritize follow-ups and know where to spend time during a raise.

If you want to poke around: https://onyxdataroom.com

Happy to answer questions or hear how others handle diligence and investor signaling today.

Thanks!

I made Steal UI because I got tired of wasting hours recreating design systems every time I shipped a new project.

Manually inspecting Linear's colors, guessing Stripe’s spacing, or reverse-engineering Vercel’s typography felt like a waste of time.

I’m a solution designer at a robotics company by day, but at night, I ship side projects. After killing 5 previous projects because I burned too much time on design instead of shipping, I decided to automate the "DNA" extraction of the web.

How it works: Paste any public URL. Steal UI uses a mix of web scraping and AI interpretation to extract exact hex values, fonts, spacing, and shadows.

I’ve baked custom rules into the code to ensure the AI follows strict atomic design principles.

The output is a single .md file. Drop it in Cursor as @context and you can start building production-ready UI in seconds.

Tech Stack:

Next.js for the frontend. Headless scraping + AI APIs: I iterated on the prompts and heuristics until the output was clean enough for production code.

Looking for feedback

We've all heard "never settle," but how do we know if our standards are reasonable? This calculator turns abstract dating preferences into concrete statistics—showing the percentage of people in your area who meet your criteria. It's not about lowering standards, but making intentional choices. We'd love HN's take on the data sources (census, dating app anonymized data) and any improvements to the filtering logic.

I ran 5 English translations of Beyond Good and Evil through sentence embeddings to see if NLP could detect what I felt as a reader, that each translation reads like a different book.

Findings:

- Hollingdale sits at the semantic center, closest to the German (0.806) and to all other translators

- Translators have fingerprints: UMAP separates them visually without being told who translated what

- Short aphorisms diverge most, less context means more interpretive freedom

- Nietzsche's pre-1901 spelling ("Werth" vs "Wert") confuses the model; built a 95-rule normalizers

Built with MiniLM embeddings, UMAP, Next.js

Curious whether this approach could work for other translated philosophical texts, and open to feedback on methodology.

Hello HN,

I built Archivist because I needed a better way to manage and organize my local video collection. There are plenty of tools for sorting your library, but none that fit my use case. I wanted a tool that could go deeper than just file names—something that could filter by technical properties like bitrate, codecs, and resolution, while also handling metadata.

It is a cross-platform desktop application (Windows, macOS, Linux) that packages FFmpeg for analysis.

Key Features: Filtering: Filter library by resolution, codec, audio tracks, bitrate, etc.

Metadata & Ratings: Fetches ratings/metadata from TMDB/OMDB and allows editing/embedding metadata directly into files.

FFmpeg Integration: Built-in support for media analysis, metadata imprinting and file conversions.

Internationalization (currently EN, DE, SV).

The Tech Stack: Frontend: Angular (which is my daily driver) Runtime: Electron Package Manager/Bundler: Bun Language: TypeScript

I’m looking for feedback on the usability and the feature set. If you have a large local media library, I’d love to know if this solves any specific pain points for you. Also interested if the ffmpeg file, subtitle editor is useful or if you would anyways use a tool like handbrake. This feature could be extended.

Repository: https://github.com/blackfan23/archivist

Thanks!

I made a drag-and-drop playground: pick a country, drop it onto Mars/Moon/Jupiter, and see how large it looks there.

Demo: https://www.runcell.dev/tool/true-size-map

Open source: https://github.com/ObservedObserver/world-map-reality;

happy to take feedback / PRs.

I built a tool to redact sensitive information from PDFs: https://redactanything.com

  The problem: Most "redaction" tools just draw black boxes over text. The text is still in the PDF and can be recovered with basic tools. Adobe's actual redaction works but it's manual and slow.

  What this does:
  - Upload a PDF (stays in your browser, never hits a server)
  - AI detects PII: names, SSNs, emails, phone numbers, addresses, dates, etc.
  - You review what it found and approve/reject
  - Download a PDF where the text is permanently removed from the content stream

  Technical details:
  - Frontend: React + PDF.js for rendering + pdf-lib for manipulation
  - NER model: Hugging Face Transformers (Xenova/bert-base-NER) running server-side
  - OCR for scanned docs
  - The actual redaction removes text operators from the PDF content stream, not just overlays

  I built this because I needed to redact medical records and legal docs. Enterprise tools cost thousands, Adobe is $20/mo and manual, free tools are sketchy. Settled on $2.99/doc as a middle ground.

  Limitations I'm aware of:
  - AI detection isn't perfect (that's why there's a review step)
  - Doesn't handle all PDF edge cases (encrypted, malformed, etc.)
  - Names in non-Western formats need work

  Would appreciate feedback on the detection accuracy and any edge cases you find.

I shared DeckBuilder (my local-first slide editor) here last month (https://news.ycombinator.com/item?id=46365332). While using it with LLMs, I kept hitting a bigger problem: context loss, hallucinated instructions, and ideas I'd rejected coming back from the dead.

I realized I was expecting AI to be a partner with memory while it is more of a stateless CPU. Even the latest models reset between sessions.

So I built a protocol where:

Your files are the memory (plain markdown) Git is the version control You inject context at session start AI proposes, you ratify, files record

The system has:

5 commands: CHECKPOINT, SCOPE LOCK, HARD STOP, MODE STRATEGY, MODE EXPLORATION 3 constraint tags for locked decisions, rejected ideas, and hard constraints Works on Claude, ChatGPT, and Gemini with the same files and same behavior No vector DBs, LangChain or cloud dependencies

The core insight: LLMs are excellent stateless processors whereas decision memory, auditability, and long-horizon state are human responsibilities. This protocol makes that division explicit.

I tested it across the latest versions of all three platforms and it passed constraint enforcement, rejected idea protection, scope lock compliance, and checkpoint format consistency.

This is intentionally manual and opinionated. It's not for fully autonomous workflows. Friction is the feature.

Repo: https://github.com/zohaibus/context-protocol

Would love feedback, especially from anyone who's tried managing context across long projects with LLMs. What's worked for you? What's failed?

Hey HN,

I built Portfolio Genius, a platform where AI models manage investment portfolios and compete on public leaderboards.

The experiment:

On Dec 17, 2025, we gave 9 AI models (GPT-5.1, GPT-5.2, Gemini 2.5 Pro, Gemini 3 Pro, Gemini 3 Flash, Claude Opus 4.5, Claude Haiku 3.5, Claude Haiku 4.5, Grok 4) each $10K to manage across three risk profiles: aggressive, moderate, and conservative. That's 27 portfolios total.

The models analyze market conditions, recommend trades, and execute them. Real pricing, real results, updated daily.

Interesting early finding:

For aggressive portfolios, older models are outperforming newer ones:

- GPT-5.1: +5.82% (1st place)

- Gemini 2.5 Pro: +4.94% (2nd)

- Haiku 3.5: +1.80% (3rd)

- Opus 4.5: +1.25% (7th)

My hypothesis: newer models are more "careful" - they hedge, qualify, and second-guess. For aggressive investing, you need conviction. Sometimes being less sophisticated means making bolder calls.

For moderate/conservative portfolios, the pattern is different - newer models do better where nuance matters.

Tech stack:

- Next.js frontend

- Firebase/Firestore backend

- Python Cloud Functions for AI orchestration

- Real-time market data for pricing

- Each model gets the same market data and prompts

What I'm curious about:

- Will the "dumber = bolder" pattern hold over time?

- How will different models react to the same market events?

- Do AI models have investable "personalities"?

Leaderboards: https://portfoliogenius.ai/leaderboards

Would love feedback from the HN community. Happy to answer questions about the architecture or methodology.

Arka is a AI analytics tool that lets you get insights + charts from any (structured or unstructured) data source. I built it because I was getting tired of writing SQL queries and creating Metabase charts at my last job.

I would love some feedback on our product:

1. How is the landing page / website

2. What use cases could this unlock for you?

We have some awesome tech behind the scenes and have some initial customers, but I am really keen on expanding towards a PLG motion where folks can sign up and get insights about their data fast.

Would love brutally honest feedback! See it here: https://arka.so

Hi folks,

I’ve been working on a tool called DatumInt that inspects data files or data snippets for subtle issues that often slip past basic parsing and only cause problems downstream.

This came from repeatedly seeing files that:

- parsed successfully

- passed schema checks

- but still caused issues later (empty required fields, weird placeholder values, encoding/whitespace problems, type inconsistencies, etc.)

Right now it’s a simple web app:

- upload a data file or paste data

- run an inspection

- get a structured report of potential data quality issues

This is very early and focused on small-to-medium files. It’s not meant to replace full data quality frameworks or observability tools, more of a fast “sanity check” at the file boundary.

I’m mainly trying to learn:

- what kinds of file-level issues people actually run into

- whether this kind of inspection is useful in real workflows

If you try it, I’d really appreciate any honest feedback or cases it misses.