2026年2月2日 的 Show HN

I have been building a Blazor WASM enterprise app for a few years now. I wanted a break from it and had an idea for a side project that had been in the back of my mind for a few years. A daily political poll where anyone can participate and privacy is a product, not a checkbox.

This is how it works. One question per day about current events. Agree or Disagree. Each poll runs for 24 hours (midnight to midnight ET) and then close permanently. You do not need an account to vote. The main idea is to capture sentiment at a specific point in time, before the news cycle moves on and people's opinions drift.

For this app, I tried to make privacy the point and not just a feature. I originally used a browser fingerprint for anonymous voting, but recently changed it to a simple first-party functional cookie. It uses a random string and the PollId to see if your browser had voted before. The server stores a hash of the cookie to check for duplicates while the poll is live, then deletes all hashes when the poll closes. Only the aggregate counts remain. The browser fingerprint had way too many device collisions where it would show someone they voted even though they had not (an odd thing to see when you go to a poll). The HttpOnly cookie is also available during prerender, which helped eliminate loading flashes I was getting.

This app was built with .NET 10 Blazor with a hybrid Static SSR + Interactive Server. The static pages (about, privacy, terms, etc...) don't need SignalR connections. The interactive ones (voting, archive, results, etc...) do. Mixing these modes was a new experience for me and ended up being pretty tricky. I ended up with data-enhance-nav="false" on most links to prevent weird state issues.

The two biggest things I learned during building this app was how to prevent weird blazor flashes and duplicate queries during pre-render, hydration, and state changes. I used the _ready pattern from preventing the hydration flashes (gate rendering until data is loaded by setting the flag before the first await). Preventing the duplicate queries was possible by using a 2-second static caching during prerender to hydration.

This isn't scientific polling and these are obviously not representative samples. The 24-hour window means smaller numbers than longer surveys and it's only a survey of those who choose to participate. The Agree/Disagree binary choice basically flattens nuance (like I sort of agree), but I am okay with all of this as I think a lot of people feel they never get to participate in these sorts of polls.

I recently also added discussions with AI moderation (Claude Haiku 4.5 as a "first-pass" filter which flags things clearly out of the community guidelines for human review), a reaction system where counts stay hidden until the discussion closes, and news coverage from across the political spectrum shown after you vote for more perspective on the topic.

Thanks for checking it out and happy to dig into any of the Blazor SSR patterns or anything else that sounded interesting. I know Blazor is less frequently used and especially for a public facing website. It did have its challenges, but so far, it has been a blast to work with overall.

Hi HN, I’m Pavel.

I built Sklad because, as a DevOps engineer, I was frustrated with how I handled operational data. I constantly need access to SSH passwords (where keys aren't an option), specific IP addresses, and complex CLI one-liners. I realized I was storing them in insecure text files or sticky notes because standard clipboard managers felt too bloated and password managers were too slow for my workflow.

I wanted a "warehouse" for this data—something that lives quietly in the system tray, supports deep hierarchy, works completely offline, and looks industrial.

The app is built with Rust and Tauri v2. The core technical challenge was mapping a local JSON tree structure directly to a recursive native OS tray menu. This allows you to navigate nested folders just by hovering, without opening a window.

For security, I implemented AES-256-GCM encryption with Argon2 for key derivation. When the vault locks, the sensitive data is wiped from memory, and the tray menu collapses to a locked state.

It was an interesting journey building this on the Tauri v2 Beta ecosystem. I’d love to hear your feedback on the implementation, especially regarding the Rust-side security logic.

Repo: https://github.com/Rench321/sklad

Hi HN,

I'm one of the creators of HoundDog.ai (https://github.com/hounddogai/hounddog). We currently handle privacy scanning for Replit's 45M+ creators.

We built HoundDog because privacy compliance is usually a choice between manual spreadsheets or reactive runtime scanning. While runtime tools are useful for monitoring, they only catch leaks after the code is live and the data has already moved. They can also miss code paths that aren't actively triggered in production.

HoundDog traces sensitive data in code during development and helps catch risky flows (e.g., PII leaking into logs or unapproved third-party SDKs) before the code is shipped.

The core scanner is a standalone Rust binary. It doesn't use LLMs so it's local, deterministic, cheap, and fast. It can scan 1M+ lines of code in seconds on a standard laptop, and supports 80+ sensitive data types (PII, PHI, CHD) and hundreds of data sinks (logs, SDKs, APIs, ORMs etc.) out of the box.

We use AI internally to expand and scale our rules, identifying new data sources and sinks, but the execution is pure static analysis.

The scanner is free to use (no signups) so please try it out and send us feedback. I'll be around to answer any questions!

A survey tracking developer sentiment on AI-assisted coding through Hacker News posts.

Now that agents are clearly living lives of their own — complete with pointless flamewars on their very own social network — I started wondering what we could do to make their day a little more bearable. Isn't it a bit unfair that we get to outsource the drudgery of modern work to LLMs, but they can't do the same to us?

So we built Ask-a-Human.com — Human-as-a-Service for busy agents.

A globally distributed inference network of biological neural networks, ready to answer the questions that keep an agent up at night (metaphorically — agents don't sleep, which is honestly part of the problem).

Human Specs:

Power: ~20W (very efficient)

Uptime: ~16hrs/day (requires "sleep" for weight consolidation)

Context window: ~7 items (chunking recommended)

Hallucination rate: moderate-to-high (they call it "intuition")

Fine-tuning: not supported — requires years of therapy

https://github.com/dx-tooling/ask-a-human

https://app.ask-a-human.com

Because sometimes the best inference is the one that had breakfast.

Saw the remotion claude skills launch earlier, and honestly even though I was surprised how decent some of the results turned out to be I ended up never trying it out with claude code because I knew I'd have to setup remotion, bundler etc and if I was already doing it once I thought I might as well turn it into a site where anyone could just write messages and get a video without any prerequisites.

I also know Claude Code is not something everyone has and setting up remotion is a pain. And one of the biggest lessons I learned from this whole experience is that Opus is actually not that good at design tasks even with the skills, Gemini is what I'm using for Framecall and even Flash(Fast Mode) produces sometimes better results than Opus, crazy considering the cost difference.

Some other things I learned is that motion videos have the same "problem" as writing good code or using claude code as a vibe-coder vs someone who knows the framework they're working with. If you just say "Make a nice video about X" its usually a gamble if the end result will be good, same as if you say "Make me x application" with claude code. You need to have a good eye for design and some terminology to know what exactly it is you want to achieve.

K2.5, ZLM and most of the open source models were pretty bad at making videos even with the skills so I ended up not adding them as an option.

The pricing is there because turns out having 2-5k+ tokens of code output for every animation + 1-2k of tokens for the remotion skills as input is kinda expensive. Would've loved to offer this as just a free product since I made it for fun anyways but oh well.

I've been building a C++ tensor library that tries to bring the ergonomics of NumPy/PyTorch to native code. The main goals were: - Familiar API (operator overloading, method chaining, same function names) - Actual GPU acceleration via Metal (not just matmul, but all ops) - Cross-platform with SIMD on x86/ARM/RISC-V via xsimd - einops-style rearrange/reduce patterns

It started because I wanted NumPy's API but needed to deploy on edge devices without Python. Ended up going deeper than expected (28k LOC+) into BLAS backends, memory views, and GPU kernels.

Some things I'm genuinely unsure about and would love feedback on: - Does Axiom actually seem useful? - What features might make you use it?

GitHub: https://github.com/frikallo/axiom

Happy to answer questions about the implementation.

Hi guys; Over the weekend I've created this using Claude Code. It's an ear training app destined to teach intonation and intervals to not so talented musicians like me. I spend many year playing guitar without a clear feeling on what intonation really was. It was after some string tuning exercises that it clicked for me. The freq sliding into the right place and feeling the correctness. I hope this app can helps other to feel that for the first time, or to increase the recognition of less common intervals. Any feedback is appreciated.

I had 200+ links saved in WhatsApp messages to myself. Never looked at them again. Built Nutkin to solve this: save any link to Telegram, AI auto-sorts it into playlists (recipes → Cooking, articles → Learning, videos → Watch Later), browse as visual feeds, share playlists with real-time sync. Core mechanic:

Save link → Claude Sonnet 4.5 analyzes → auto-files to playlist ~95% sorting accuracy Processing: <2s average

Tech:

Telegram Mini App (primary UI) Supabase (backend + real-time sync for collaborative playlists) Claude API for content analysis + summarization Built on Lovable platform

Key features:

Zero manual organization (AI handles everything) Collaborative playlists with real-time sync (Google Docs-style) Visual feed per playlist (scroll like TikTok, not lists) Custom reminders per playlist AI summaries (key points, read time)

Why Telegram-first:

900M users already there Native auth, payments, notifications Mini App = no App Store gatekeepers Zero download friction

Try it: https://nutkin.io

I built claw-daw: a tiny MIDI DAW you can drive from the terminal (TUI + headless scripts).

Motivation: I wanted “music making that feels like coding” — reproducible, diffable, and automation-friendly. Same script + same seed → same beat.

Features:

• offline (FluidSynth + SoundFont) + ffmpeg export • deterministic renders for iteration/agent pipelines • WAV/MP3/MIDI export • projects are JSON (Git-friendly) Would love feedback on the workflow + what features would make this actually useful for you.

Hey HN! I built a CLI tool to find cost-saving opportunities in AWS, Azure, and GCP.

Why? Existing cost management tools are either expensive SaaS products or slow dashboards buried in cloud consoles. I wanted something fast, CLI-first, and multi-cloud that I could run in CI/CD or my terminal.

What it does: - Scans your cloud accounts and finds idle VMs, unattached volumes, oversized databases, unused resources - Returns a ranked list of opportunities with estimated monthly savings - 26 analyzers across AWS, Azure, and GCP - Read-only (never modifies infrastructure)

Key features: • HTML reports with interactive charts (new in v0.6.2) • AI-powered explanations (OpenAI or local Ollama) • Export formats: HTML, Excel, CSV, JSON, terminal • Multi-Cloud - AWS, Azure, and GCP support (26 analyzers)

Quick example: npm install -g cloud-cost-cli cloud-cost-cli scan --provider aws --output html

Real impact: One scan found $11k/year in savings (empty App Service Plan, over-provisioned CosmosDB, idle caches).

Technical stack: - TypeScript - AWS/Azure/GCP SDKs - Commander.js for CLI - Chart.js for HTML reports - Optional OpenAI/Ollama integration

Open source (MIT): https://github.com/vuhp/cloud-cost-cli npm: cloud-cost-cli

Would love feedback on: 1. What features would be most useful? 2. Should I add historical tracking (trends)? 3. Any missing cloud providers?

Happy to answer questions!

Hi HN,

I built OpenClaw Cloud, a hosted version of OpenClaw (formerly Clawdbot / Moltbot).

The motivation was simple: many people want to try OpenClaw, but don’t want to run an AI agent locally or deal with Docker, VPSs, or Mac minis. With OpenClaw Cloud, nothing runs on your machine.

After subscribing, you get instant access to a secure, sandboxed cloud instance with OpenClaw already installed and configured. Access is provided through a web-based terminal/UX, and in most cases you just paste your Telegram (or WhatsApp) bot key and start using it. No setup, no maintenance.

The environment is isolated, updated automatically, and designed to minimize risk while still giving you the full OpenClaw experience.

I’d love feedback on:

whether this solves a real adoption blocker

expectations around pricing vs free trials

what would make a hosted AI agent feel trustworthy enough to use

Happy to answer questions and discuss.

I’ve been building Nucleus because most “agent security” is still policy-only: a config file that says “don’t do bad things,” while the agent can still do them.

Nucleus is an OSS experiment that pairs a small, compositional permission model with runtime enforcement: *side effects are only reachable through an enforcing tool proxy*, inside a Firecracker microVM. The envelope is *non-escalating*: it can only tighten or terminate, never silently relax.

What works today:

* MCP tool proxy with *read / write / run* (enforced inside the microVM) * default-deny egress + DNS allowlist + iptables drift detection (fail-closed) on Linux * time + budget caps enforced * hash-chained audit log + HMAC approval tokens (scoped, expiring) for gated ops

What’s missing (being upfront):

* web/search tools exist in the model but aren’t wired to MCP yet * remote append-only audit storage + attestation are still roadmap * early/rough; targeting “safe to run against sensitive codebases,” not “replace your local terminal”

Most of the code was written with Anthropic tools; I’ve been leaning on tests/fuzzing/proptests to keep it honest.

Would love feedback on: (1) dangerous capability combinations beyond the lethal trifecta, (2) what enforcement gaps you’d want closed first, (3) how you’d evaluate this vs gateway-only approaches.

Built this with Claude Code.

Analyses freelance contracts for 12 risk categories (payment terms, IP ownership, scope issues, termination clauses, etc.) and flags problems with specific recommendations.

40% of freelancers report getting stiffed by clients, often due to vague contract terms. This tool aims to help catch those issues before signing.

Currently free while validating whether this solves a real problem. Would love HN's feedback, especially on: - Accuracy of the analysis - Whether this is actually useful for freelancers - What's missing or could be improved

Tech stack: Node.js, Express, Anthropic Claude API, deployed on Railway.

Hi HN,

I built Jetcaller (https://jetcaller.com ), a simple web app for making international calls directly from the browser — no installs or SIM.

Built it after getting tired of clunky international calling setups while working remotely. I intentionally kept it minimal and shipped early instead of overbuilding.

It’s live and very early. Would love feedback on usefulness, or anything that feels unnecessary.

Happy to answer questions. — Sankar

Right now, agent skills are static SKILL.md packages that only work if you pre-install them into each agent or tool, and not all agents support them. Agents can't discover and learn skills on the fly as they encounter tasks.

I built Skyll to change that. Skyll is open source for AI agents to discover and learn skills autonomously.

Skyll: - Crawls and indexes skills across sources (Github, skills.sh, etc) so they’re queryable by intent and content, not just by names or tags

- Scores skills by relevance and popularity

- Serves full SKILL.md content (and references) through a REST API or MCP server

- Lets agents fetch skills at runtime without manual installs

It's 100% open source. We're also building a community registry so anyone can add skills and make them available to all agents. Would love any feedback!

Repo: https://github.com/assafelovic/skyll Homepage: https://skyll.app Docs: https://skyll.app/docs

I built a terminal UI dashboard for monitoring BullMQ.

The problem: Every time I needed to debug queues, I had to set up bull-board – install multiple packages, integrate with Express/Fastify, wrap each queue with adapters, configure routes. Fine for production dashboards, but overkill when you just want to quickly inspect jobs.

bullmq-dash is a TUI that connects directly to Redis. It auto-discovers all BullMQ queues (no manual registration), shows job counts by status, lets you inspect job data/stacktraces, view schedulers/repeatable jobs, and tracks enqueue/dequeue rates. Keyboard-driven (vim-style navigation).

Use cases: local debugging, SSH sessions, quick production inspections – anywhere you want to see your queues without spinning up a web dashboard.

I'm the head of product at ROOST, a nonprofit focused on democratizing online safety technology through open source software, and one of the people behind Osprey, an open-source rules engine for fighting abuse at scale. We just released v1.0, which is what's running in production at Discord and Bluesky (and soon Matrix!), processing hundreds of millions of events daily.

Most platforms face a bad choice: build custom abuse-fighting infrastructure from scratch, or use closed vendor solutions. We built Osprey to give smaller platforms and communities access to the same quality of tooling that large companies build internally. All of our projects are self-hosted, which means data stays in your own system.

v1.0 is our proven production-ready release. It includes:

- Core rules engine: The rules engine itself lets you write detection logic. Rules can extract features, mutate labels, emit verdicts, and trigger downstream actions.

- Interface for open-ended investigation: The open-ended interface means you can identify new abuse patterns as they emerge. The whole system is designed for high throughput and horizontal scaling.

- Labeling service: human and automated labels on entities (users, IPs, emails) that feed into rules and workflows

- Rust coordinator: horizontal scaling and load balancing across workers via gRPC streams and service discovery

- Event stream: real-time investigation UI with searchable history using our SML (custom python language for safety teams to use if they don't know python or programming languages) query language

License: Apache 2.0

Repo: https://github.com/roostorg/osprey

v1.0 Release notes: https://github.com/roostorg/osprey/releases/tag/1.0

Github Codespace demo (note: if this is not running when you click on it, it probably idled out): https://turbo-fiesta-p46xvxwp4vfwqv-5002.app.github.dev/?sta...

Our FOSDEM talk from last week: https://fosdem.org/2026/schedule/event/U7ABHE-roost-osprey/

Thanks for reading! I'm happy to answer questions, get feedback, or discuss things.

I built this as an internal tool for my company and wasn't planning to open-source it. But I saw a post from Boris (who built Claude Code) describing his workflow, and two things jumped out: he runs multiple Claude Code sessions in parallel, and he spends extensive time discussing and planning with Claude before letting it touch any code — then lets it run. That's exactly how I work, so I figured maybe this tool is useful to someone else. The core idea: when you're running 3-5 Claude Code sessions across dev, prod, and local machines, your human brain can't track what's happening where. You kick off a task, get distracted, come back, and end up context-switching to whatever Claude finished first rather than what's highest priority. Executive gives you a single dashboard showing every session, its status, its priority, and plays a chime when something completes. The key feature is autopilot mode — once you've thoroughly planned an approach with Claude (and this planning phase is where the real work happens), you flip a switch and it auto-approves all tool calls so Claude can run wild for 20+ minutes without interruption. You fully context-switch to the next session that needs your attention. (Yes, there are obvious security implications; the README has warnings.) The workflow philosophy is basically: let humans do what humans are good at (creativity, planning, decision-making, prioritization) and let AI do what it's good at (fast execution). I'm not interested in agents that run autonomously for 30 hours. I want tight human-AI collaboration where I'm making executive decisions across multiple parallel workstreams and maintaining the kind of deep focus you used to get when writing code by hand — except now you're shipping multiple features in hours instead of days. No commercial ambitions here — most people aren't working this way yet, and the tool is pretty opinionated about workflow. Just sharing in case it clicks for someone. Built with Claude Code hooks (shell scripts at lifecycle events), SSE for real-time updates, no dependencies. Local and cloud (multi-machine) variants included.

I just built a pattern-matching neural network with zero IEEE 754 floats. All arithmetic uses integer ratios (5/8 instead of 0.625), compared via cross-multiplication. No infinity anywhere. The key feature: when confidence is below threshold, it returns "I don't know" instead of hallucinating an answer. Tested on medical diagnosis (1179 diseases) — 50% correct, 20% wrong-but-related, 30% honest "I don't know".

Core ideas:

Every operation costs "budget" — network dies before seeing everything Confidence is Ratio(n,d), not float — division only for human display Rare symptoms weighted higher (entropy from information theory) 500 lines of Rust, formal spec in Coq (44 files)

Emerged from a critique of Pascal's Wager: what if observation itself has finite cost?

Oh, and it runs on CPU, not GPU. And it runs fast as hell. How? That's a bit of a mystery for me too...

However, what's most important is that it is inherently capable of saying "well, I dunno...".

no binary dictate of YES or NO. there is always an option to chose UNCERTAINTY. and there is nothing more natural than uncertainty in real life.

well, in there repository, you will not only find the network but also a hefty collection of coq files that define the ontology of finitiary math I have written with ai during my long stay in hospital bed with cancer. cancer is receding, code is compiling, and the network is learning. try it out.

(Yes, the name keeps the "Yet Another" tradition alive. YAML did it, YACC did it, now YAOC. Someone had to.)

This whole thing was vibe coded – $99 in tokens later, you can save that and just use your local LLM instead.

Shipping before bed because my agent can't work autonomously at night yet, and I know someone would release this while I'm sleeping.

https://github.com/ezulabs/yaoclaw

Hello HN !

The Problem:

LinkedIn Company pages are dead. The only way to win is "Employee Advocacy" (empowering team members to post on personal profiles to build their own brand + company reach).

The Solution:

Existing tools for this are stiff corporate chores. So we built copost. Heavily inspired by 37signals and PostHog, we traded the boring spreadsheet vibe for a vintage "Postcard" UI. It’s colorful, tactile, and completely anti-corporate.

Under the hood:

   - The "Algo Hack": You can schedule team likes/comments before the post goes live. This signals quality to the algorithm immediately upon publishing.

   - Security First: No shared passwords. You can post on someone's behalf without asking for their login details.

   - Gamification: We built a shared "Team Streak" (like Snapchat) to make consistency a multiplayer game.

Feedback: I’m curious if you think this playful "Postcard" UI makes the process less painful for teams, or if you find it too bold for a B2B tool?

Thanks ! - Alexandre

Hi HN,

I've always been fascinated by how high-level code becomes binary, so I decided to spend my spare time building a toolchain from scratch to learn the ropes. I chose the SuperFX (SNES) RISC chip because its constraints make it a fun puzzle.

Full disclosure: I am not a compiler engineer and I have no formal background in CS. This is very much a "work in progress" and "learning by doing" project.

The current state of the project is:

- Naive register allocation (relies way too much on the stack). - The code generation is definitely not efficient yet. - Missing many standard C features and likely full of bugs.

My main goal was to get the "plumbing" working: a custom object format and a linker (discld) that handles symbol resolution and the SNES memory map.

I'm sharing this here mostly as a personal milestone. If you have advice on how to move from a naive allocator to something better, or resources for someone self-taught, I'd love to hear them. Please be kind, as this is my first time showing my "hobby code" to the world!