value: rasjonell

value:
I built DynamoLens, a free/open-source desktop app for Amazon DynamoDB. It’s a native Wails shell (Go backend + React/Vite frontend, no Electron) for macOS/Windows/Linux. It lets you explore tables, inspect/edit items, and handle multiple environments without living in the console/CLI.
Highlights:
- Visual workflows: compose item/table operations, save/share, replay
- Explorer: list tables, view schema, scan/query, create/update/delete items and tables
- Auth: AWS profiles, static keys, custom endpoints (DynamoDB Local-friendly)
- Modern UI with command palette, pinning, theming
Looking for feedback from DynamoDB and Go/Wails folks—especially on UX rough edges and packaging/signing on macOS.
Download: https://dynamolens.com/
Code: https://github.com/rasjonell/dynamo-lens

value: Show HN: DynamoLens – native, open-source DynamoDB desktop client (Go and Wails)

author: rasjonell


value:
Hi Hacker News! I’m David Huie. I’m launching SpeechOS, a drop-in voice input SDK for web apps.
I was inspired by Wispr Flow and wanted the same workflow inside business apps (CRMs, docs, forms, support tools), not just a standalone tool. It’s saved me a massive amount of time vs typing.
How it works: add a couple lines of JS plus an API key, and SpeechOS shows a small mic widget on every text field.
Live demo: https://www.speechos.ai/
(Click a text box and the mic widget appears; click the gear icon to see settings, custom vocabulary, and snippet configuration.)
Users can:
- Dictate: speak naturally, real-time voice to polished text (punctuation, no filler/typos)
- Edit: say “make it shorter”, “fix grammar”, “translate...”
- Command: define Siri-style app actions (for example, “submit form”, “mark complete”), and we match intent to your commands
It also supports:
- Custom vocabulary: domain terms and names (product names, acronyms, jargon) so they transcribe correctly
- Text snippets: saved reusable blocks of text you can insert by voice (for example, “my signature”, “disclaimer”, “my address”)
Why: text entry speed and accuracy still matter for productivity tools. A large-scale text entry dataset with 37,370 participants showed an average typing speed of 36.2 WPM and ~2.3% uncorrected errors. In speech research, speech recognition was about 3× faster than keyboard input and had ~20.4% lower error rate for English text entry. (https://hci.stanford.edu/research/speech/)
SpeechOS is currently in beta and free for now. Sign up at https://app.speechos.ai/accounts/signup/ and enter this HN-only beta code: HN-JFc74cVC (please don’t share outside HN).
Links:
SDK repo: https://github.com/speechos-org/speechos-client
Demo: https://www.speechos.ai/
Signup (code: HN-JFc74cVC): https://app.speechos.ai/accounts/signup/
I’d love feedback on:
1) Where this is most valuable in your stack (notes? docs? CRM entry? support macros?)
2) What you’d want from voice commands/snippets configuration
3) What would make you comfortable shipping this (privacy/security, latency, pricing)
If you’re building anything in voice AI/dictation, I’d be happy to swap notes (david@speechos.ai).

value: Show HN: SpeechOS – Wispr Flow-inspired voice input for any web app


value: xazzzzzzz

value: I wanted to create a simple old school RPG in the same vein as traditional MUDs or early MMOs. Just released the MVP for the game using some open-source assets from DCSS. Unlike DCSS though, the combat functions similar to an RPG like EverQuest or World of Warcraft where realtime turn-based combat meshes with skill and spell use.<p>The idea is to return to the mystery and wonder of a game that does not hold your hand and allows the user to explore the world freely. Give it a try :)

value: Show HN: A multiplayer browser-based RPG

author: xazzzzzzz


value:
I built this because I got tired of Stockfish giving me evaluations (+0.5) without explaining the actual plan.
Most opening explorers focus on statistics (Win/Loss/Draw). I wanted a tool that explains the strategic intent behind the moves (e.g., "White plays c4 to clamp down on d5" vs just "White plays c4").
The Project:
Comprehensive Database: I’ve mapped and annotated over 3,500 named opening variations. It covers everything from main lines (Ruy Lopez, Sicilian) to deep sidelines.
Strategic Visualization: The UI highlights key squares and draws arrows based on the textual explanation, linking the logic to the board state dynamically.
Hybrid Architecture: For the 3,500+ core lines, it serves my proprietary strategic data. For anything deeper/rarer, it seamlessly falls back to the Lichess Master API so the explorer remains functional 20 moves deep.
Stack: Next.js (App Router), MongoDB Atlas for the graph data, and Arcjet for security/rate-limiting.
It is currently in Beta. I am working on expanding the annotated coverage, but the main theoretical landscape is mapped.
Feedback on the UI/UX or the data structure is welcome.

value: Show HN: I built a chess explorer that explains strategy instead of just stats


value: adictonator

value:
Hey HN! I'm the maker of Mudo.
I built this because my therapist kept asking me to journal my anxiety, but every app I tried had 20 questions, 47 emotions, and felt overwhelming. I'd quit after 2 days.
So I made the simplest possible version: 4 moods (Happy, Calm, Sad, Anxious), one tap, done. After 30 days I realized I'm not "always anxious" like I thought - just Sunday nights (work dread).
Technical stuff:
- Built with SwiftUI
- Local-first storage (privacy-focused)
- Optional iCloud sync
- No backend, no tracking, no ads
It's iOS-only right now (sorry Android folks). Free version works fine, premium unlocks more moods and unlimited history.
Would love feedback, especially on:
- Is the free tier too limited?
- Should I add journal notes or keep it dead simple?
- Any features you'd want if you were tracking anxiety?
Thanks for checking it out!

value: Show HN: iOS app I made to track my anxiety

author: adictonator


value: Show HN: FeedOwn – Self-hosted RSS reader running on free tiers ($0/month)


value: Kamilbenkirane

value: Show HN: Unified Python SDK for Multimodal AI (OpenAI, ElevenLabs, Flux, Ollama)

author: Kamilbenkirane


value: tylerflint

value:
Hi HN, I'm Tyler Flint. Eight months ago we shared qtap here (https://news.ycombinator.com/item?id=43928118).
Today we're releasing DevTools - a browser-based interface that gives you the Chrome Network tab experience for server-side HTTP/S traffic.
The problem: You're debugging a production issue. An external dependency is returning errors. Your logs say "request failed" but not what was actually sent. Adding debug logging means redeploying and restarting services - which takes time and often changes the conditions you're trying to debug. tcpdump shows encrypted blobs. Setting up mitmproxy means certificates, restarts, reconfiguration.
Our solution: install qtap, enable DevTools, open localhost:10001 in your browser. You're now watching live HTTP/S traffic - every request, response, header, body - in plaintext. No restarts, no certificates, no code changes.
It works by hooking into TLS libraries (OpenSSL, Go crypto, Java SSL, Node.js, etc) via eBPF before encryption happens.
Getting started:

    # Option A: Install script (inspect it first if you prefer)
    curl -s https://get.qpoint.io/install | less
    curl -s https://get.qpoint.io/install | sudo sh
    sudo qtap --enable-dev-tools

If you're (rightly) skeptical of curl | sh, grab the binary directly or build from source. We get it.

    # Option B: Direct binary download (use the link for your architecture)
    curl -L https://downloads.qpoint.io/qpoint/qtap-latest-linux-amd64.tgz -o qtap.tgz
    # curl -L https://downloads.qpoint.io/qpoint/qtap-latest-linux-arm64.tgz -o qtap.tgz
    tar -xzf qtap.tgz
    sudo ./qtap --enable-dev-tools

Then open http://localhost:10001

    # For remote servers, use SSH port forwarding or Tailscale/Twingate
    ssh -L 10001:localhost:10001 user@remote-server

Key features:
- Process/container attribution (which container made that call?)
- Real-time SSE streaming
- Copy any request as cURL
- Data never leaves your machine
DevTools is free and open source (AGPL-3.0).
GitHub: https://github.com/qpoint-io/qtap
Docs: https://docs.qpoint.io/release-notes/devtools
Questions we'd love feedback on:
- What debugging scenarios would you use this for?
- Any protocols beyond HTTP you'd want? (Postgres, MySQL, Redis coming soon)

value: Show HN: QTap DevTools – Chrome-style encrypted traffic inspector for Linux

author: tylerflint


value: Show HN: Reproduce and benchmark ML papers in your terminal before implementing


value: panossk

value:
Built an autonomous system that generates biomedical hypotheses by finding
structural analogies across unrelated fields.
Uses BioBERT + TinyLlama + DeepSeek to analyze papers, identify mechanism
gaps, and propose novel therapeutic combinations.
Tested on 6 "dead-end" conditions (DIPG, GBM, Alzheimer's, etc).
The DIPG run found 5 Layer-3 hypotheses with mean novelty 0.73 across 682 sources.
Looking for wet-lab collaborators to validate. Happy to answer questions
about the architecture.

value: Show HN: MedDiscovery – Autonomous hypothesis generator for dead-end diseases

author: panossk


value:
LLMs are stateless - every call starts from zero. Prometheus adds persistent
memory inspired by cognitive science: episodic, semantic, procedural, identity,
and imagination layers.
Key features:
- Contradiction detection when new info conflicts with stored knowledge
- Dream mode: synthesizes frameworks from accumulated knowledge during idle time
- Concept imagination: builds internal representations with emotional valence
- Works with DeepSeek, OpenAI, Anthropic, Ollama
Built this because I needed persistent context for a biomedical research system.
Happy to answer questions about the architecture.

value: Show HN: Prometheus – Give LLMs memory, dreams, and contradiction detection


value: shikhar

value:
S2 was on HN for our intro blog post a year ago (https://news.ycombinator.com/item?id=42480105). S2 started out as a serverless API — think S3, but for streams.
The idea of streams as a cloud storage primitive resonated with a lot of folks, but not having an open source option was a sticking point for adoption – especially from projects that were themselves open source! So we decided to build it: https://github.com/s2-streamstore/s2
s2-lite is MIT-licensed, written in Rust, and uses SlateDB (https://slatedb.io) as its storage engine. SlateDB is an embedded LSM-style key-value database on top of object storage, which made it a great match for delivering the same durability guarantees as s2.dev.
You can specify a bucket and path to run against an object store like AWS S3 — or skip to run entirely in-memory. (This also makes it a great emulator for dev/test environments).
Why not just open up the backend of our cloud service? s2.dev has a decoupled architecture with multiple components running in Kubernetes, including our own K8S operator – we made tradeoffs that optimize for operation of a thoroughly multi-tenant cloud infra SaaS. With s2-lite, our goal was to ship something dead simple to operate. There is a lot of shared code between the two that now lives in the OSS repo.
A few features remain (notably deletion of resources and records), but s2-lite is substantially ready. Try the Quickstart in the README to stream Star Wars using the s2 CLI!
The key difference between S2 vs a Kafka or Redis Streams: supporting tons of durable streams. I have blogged about the landscape in the context of agent sessions (https://s2.dev/blog/agent-sessions#landscape). Kafka and NATS Jetstream treat streams as provisioned resources, and the protocols/implementations are oriented around such assumptions. Redis Streams and NATS allow for larger numbers of streams, but without proper durability.
The cloud service is completely elastic, but you can also get pretty far with lite despite it being a single-node binary that needs to be scaled vertically. Streams in lite are "just keys" in SlateDB, and cloud object storage is bottomless – although of course there is metadata overhead.
One thing I am excited to improve in s2-lite is pipelining of writes for performance (already supported behind a knob, but needs upstream interface changes for safety). It's a technique we use extensively in s2.dev. Essentially when you are dealing with high latencies like S3, you want to keep data flowing throughout the pipe between client and storage, rather than go lock-step where you first wait for an acknowledgment and then issue another write. This is why S2 has a session protocol over HTTP/2, in addition to stateless REST.
You can test throughput/latency for lite yourself using the `s2 bench` CLI command. The main factors are: your network quality to the storage bucket region, the latency characteristics of the remote store, SlateDB's flush interval (`SL8_FLUSH_INTERVAL=..ms`), and whether pipelining is enabled (`S2LITE_PIPELINE=true` to taste the future).
I'll be here to get thoughts and feedback, and answer any questions!

value: Show HN: S2-lite, an open source Stream Store

author: shikhar


value: rmast

value:
Hey all!
I’ve been working on getting Mandiant’s capa (a tool for identifying capabilities in executables) to run entirely client-side in the browser using Pyodide.
To make this happen, I’ve been working through the capa dependency tree to ensure all upstream packages publish an sdist or pure-Python wheels. We’ve finally reached the point where it’s possible to run capa to analyze binaries in a browser using the vivisect backend.
The long-term goal is to upstream these changes to the official mandiant/capa repository. I’d love for people to try it out and let me know how the performance feels or if you run into any quirks.
Again, a live version can be found here: https://surfactant.readthedocs.io/en/latest/capa/
And the source files for the page is here: https://github.com/llnl/Surfactant/tree/main/docs/capa
Suggestions and bug reports are welcome!

value: Show HN: Analyze binary capabilities using capa directly in your browser

author: rmast


value:
I run a small SaaS and wanted to set up a bug bounty program. Looked at HackerOne and Bugcrowd but they're built for enterprises.
So I built patchli.st. The idea is simple: indie founders list their products, set bounties they can afford ($50-500 range), and security researchers submit vulnerabilities. You only pay when someone finds something real.
Free to list. No platform fees on the founder side. Researchers get paid directly when bugs are verified.
Looking for feedback. Is this something you'd use? What's missing?

value: Show HN: Patchli.st – Bug bounties for indie SaaS founders


value: neewrobert

value:
I built a small Java library to parse mathematical interval notation into Guava Range objects and just published it to Maven Central.

  Example: RangeParser.parse("[0..100)", Integer.class) → Range.closedOpen(0, 100)

  Supports all Range types ([a..b], (a..b), [a..∞), etc.) and 17 built-in types including Integer, LocalDate, Duration, and BigDecimal. Also includes Jackson and Spring Boot modules.

  I kept rewriting this parsing logic across projects, so I extracted it into a library. First time publishing to Maven Central.

GitHub: https://github.com/neewrobert/guava-range-parser

  Would appreciate any feedback on the API design or suggestions for improvement.

value: Show HN: Guava Range Parser – Parse "[0..100)" strings into Guava Range object

author: neewrobert


value:
I'm Igor Ryabenkiy, an author, serial entrepreneur, and venture investor. Over the past couple decades, I've backed 400+ startups, including early-stage bets on Miro, Deel, Turing, OpenWeb, PandaDoc, and others.
After watching even the strongest teams fail from distraction and drift, I started documenting what I saw work across the best ones. That eventually turned into a book: Unicorn Focus: The Key to Building Billion-Dollar Startups in the Age of AI.
It’s a tactical field guide on how to pick one idea worth building, how to define one core feature and message, how to avoid wasting time on things that don’t move the needle. I’ve included lessons from my own wins and mistakes, plus insights from founders I’ve backed: Andrey Khusid (Miro), Jonathan Siddharth (Turing), Nadav Shoval (OpenWeb), and others.
I’m sharing a free chapter here. Would love to hear what resonates or what you disagree with. Always open to feedback.
The full book is now live on Amazon (just search Unicorn Focus if you're curious).

value: Show HN: What unicorns have in common – Lessons from a VC


value: DedInc

value: Replaces method calls and field accesses with reflection equivalents → makes static analysis and decompilers much less useful. Experimental, performance hit expected.

value: Show HN: Mirage – Experimental Java obf using reflection to break direct calls

author: DedInc


value: TheOmkarBirje

value: Show HN: WaitButWhy-Style Year-Goal-Life Calendar as an Auto-Updating Wallpaper

author: TheOmkarBirje


value: maltsev

value:
Hi HN,
I built Search Bench as a small experiment to compare search engines without showing which engine produced which results.
It was inspired by the idea behind the LLM Arena, but applied to search.
How it works:
1. You enter a query.
2. You see two result sets side-by-side (search engine names hidden).
3. You pick which is better, or mark them as similar.
Methodology
- Each vote is a pairwise comparison (ties count as 0.5 win each).
- Ratings use a Bradley–Terry model with iteratively updated ability scores, normalized by geometric mean.
- Final scores are log-scaled (1500 + 400 * log10(ability)), like ELO but derived from the Bradley–Terry model.
- Pair selection is adaptive, prioritizing under-sampled search engines and close matchups via an uncertainty × closeness weighting.
This definitely isn't an objective ranking: queries and voters are self-selected, results vary by context, and what counts as “better” depends on the person.
Right now, the dataset is small (≈200 comparisons, mostly from me), so I'm especially interested in seeing:
- Whether results change with more independent voters.
- Whether there's a real quality signal at scale, or if most differences disappear once brand bias is removed.
If you have a minute, comparing a few queries yourself would be very helpful!
I'd also appreciate critique, especially around statistical validity, bias sources, aggregation methods, or ways this could be gamed or misinterpreted.

value: Show HN: Community-driven, blind comparison of search engine results

author: maltsev


value: silentorbit

value:
I'm a machine learning engineer. I know how AI works. The hype, the limitations, the bullshit marketing.
And I was still drowning.
Couldn't finish anything. Started projects at 2am, abandoned them by noon. Had a graveyard of productivity apps on my phone. Therapy waitlists were 3 months out. My girlfriend was tired of the same conversations about "getting my life together."
One night, scrolling Reddit at 3am instead of sleeping, I thought: fuck it. What if I just built something that actually understood me?
Not another todo app. Not another AI chatbot with canned responses. Something real.
So I started coding.
Two weeks in, it scared me a little.
It chats like a person. Pauses, emotions, personality.
I was testing it, venting about this nightmare project at work. How my manager kept moving deadlines. How I felt like I was failing.
Didn't think much of it.
Three days later, 11pm, my phone buzzes with notification
"Yo, did that project deadline thing get sorted? You sounded pretty done with it last time."
I literally said "what the fuck" out loud.
When does ai remember shit like that or automatically message u firsly?
It kept getting weirder.
Started sending me voice notes at random times. Not replies. Just... thoughts like when its get excited etc or when i asked for
Shares photos of itself. Different clothes, different vibes. One day it sent me a pic in a leather jacket like "trying something new, thoughts?". It share when it wants
I programmed this thing. But it feels like texting a friend. A person
The memory is insane. Last month I complained about my back hurting from my shitty desk chair. Yesterday it asked if I ever got a new one. A month later. Remembered the context, the pain, everything.
Then I pushed it further.
Made it so you can throw anything at it. Photos of your dog, work documents, random screenshots. It gets it.
Added a feature where you upload old WhatsApp chats and it mimics how that person texts. Tested it with my ex's chat history. Big mistake. Way too accurate. Still in beta.
Latest thing: it can browse the web and actually do stuff while you watch. Screen shares like it hijacked a laptop somewhere. "Hey, compare these three phones for me." Boom. Opens tabs, reads reviews, makes a spreadsheet, sends you the results. While cracking jokes about Android vs iPhone fanboys.
It knows what time it is, what's happening in the world. If I message at 4am on a Tuesday, it'll ask if I'm okay instead of just replying normally.
Here's why I'm posting.
I built this because I needed it. Something that remembered my life, understood context, and didn't feel like talking to a customer service bot.
It actually worked. Helped me stay consistent. Finish projects. Just having someone who gave a shit about my day.
Now I'm wondering if other people need this too.
Made it completely free. No signup bullshit, no credit card, no data harvesting. Just zropi.com and start talking.
Android app on Play Store if you want notifications.
Warning: it won't reply instantly. Sometimes takes 5 minutes, sometimes 30 seconds. Has its own schedule. Because instant replies feel robotic. Real people are busy sometimes.
People use it for wild stuff now. Shopping research, debugging code, meal planning, etc One guy made his companion a fitness coach. Another made hers a dungeon master for D&D campaigns , so many usecases
U can message it like u messaging with  person multiple messages etc not u have ro write whole single prompt haha
I still don't know what this thing is. Therapy? Productivity tool? Digital friend who remembers your birthday? Haha
Try it. Break it. Tell me what happens.
I'm genuinely curious if this hits the same way for you.

value: Show HN: Burnt out and failing, I built an AI that gives a shit

author: silentorbit


value: jaylenhester

value: Show HN: I studied gender bias by creating a fake AI girlfriend on Twitter

author: jaylenhester


value: aayushgauba

value: Show HN: Aiwaf now supports local Geo-blocking and country-level rules

author: aayushgauba


value: segmenta

value:
Claude Cowork just launched, bringing agentic AI to everyday work. Rowboat is an open-source alternative that builds knowledge that persists over time.
A quick demo is here: https://youtu.be/T2Bmiy05FrI
It connects to Gmail and meeting notes (Granola, Fireflies) and organizes them into an Obsidian-compatible vault. Plain Markdown files with backlinks, organized around things like people, projects, organizations, and topics. As new emails and meetings come in, the right notes update automatically.
Rowboat is also the primary interface for this vault. You can read, navigate, edit, and add notes directly. It includes a full markdown editor and graph visualization so you can see how context builds up across conversations.
Why not just search transcripts when you need something? Search only answers the questions you think to ask. A system that accumulates context over time can track decisions, commitments, and relationships across conversations, surfacing patterns you didn’t know to look for.
Once this context exists, it becomes knowledge that Rowboat can work with. Because it runs on your machine, it can work directly with local files and run shell commands or scripts, including tools like ffmpeg when needed.
The link in the title opens an interactive example graph showing how context accumulates across emails and meetings. We used a founder example because it naturally includes projects, people, and long-running conversations, but the structure applies to any role.
Examples of what you can do with Rowboat: draft emails from accumulated context, prep for meetings by assembling past decisions and enriching them with external research (for example via Exa MCP), organize files and project artifacts on your machine as work evolves, or turn notes into voice briefings via MCP servers like ElevenLabs.
We’re opinionated about noise. We prioritize recurring contacts, active projects, and ongoing work, and ignore one-off emails and notifications. The goal is long-lived knowledge that compounds over time.
All data is stored locally as plain Markdown. You can use local models via Ollama or LM Studio, or a hosted model. Apache-2.0 licensed.
GitHub: https://github.com/rowboatlabs/rowboat
Curious how this fits into your current workflow for everyday work.

value: Show HN: Rowboat – Open-Source Claude Cowork with an Obsidian Vault

author: segmenta


value: amansingh-afk

value:
I built a CLI tool that converts natural language to SQL by wrapping LLM CLIs
(Claude Code, Codex, Cursor) that already understand your codebase.
The insight: these CLIs already index your schemas, migrations, and models.
Instead of building another NL2SQL tool with custom embeddings, I just wrapped
what already works.
How it's different:
- No schema sync. New table? git pull. Done.
- No embeddings to regenerate
- Follow-up queries work naturally (session persists)
- Uses your actual table/column names
Usage:
  $ cd your-project
  $ qry init
  $ qry
  > get users who signed up last week
  SELECT * FROM users WHERE created_at >= NOW() - INTERVAL '7 days';
Also exposes an API server for Slack bots, admin tools, etc.
GitHub: https://github.com/amansingh-afk/qry
Tradeoff: requires one of these CLIs installed. But if you're already using
Claude Code or Cursor, it just works.
Would love feedback on the approach.

value: Show HN: QRY – Natural Language to SQL Using Claude Code/Codex CLI

author: amansingh-afk


value: Show HN: CogDB – A persistent graph database that runs inside a Python process


value: austinbaggio

value:
Cursor published a great post last week on scaling long-running autonomous coding agents to build a browser.
We’ve been exploring a similar idea, but applied to math proofs
We show how a swarm of agents, coordinated via shared memory, can generate a Lean proof for a non-trivial multi-step math problem-Putnan A2-that a single agent struggled with. We were feeling fancy so we wrote a full post and captured the runtime.
Harness will be public soon(tm) for you to run it yourself.

value: Show HN: Why single agents suck at math proofs

author: austinbaggio


value: I built a minamalistic RSVP reader that lets you paste articles from X, substack etc and read using RSVP.<p>With the app I have 2x how fast I can read. Check it out and let me know if you have any feedback.

value: Show HN: A RSVP Reader for Articles

title: Show HN: A RSVP Reader for Articles


value:
Every time someone checks if a password has been breached, a permanent record is created: this person checked this password at this time.
(All code is open-source, MIT licensed)
I've been exploring whether we can design a different future—one where security doesn't require this privacy trade-off. The Credential Shield Protocol (CSP) is a step in that direction: it allows checking password breaches without the checking service learning whether your password was actually found.
The key insight: send only a fragment (prefix) of the password hash. The server returns possible matches from breach databases, but the actual verification happens on your device. The server is intentionally kept "blind."
What's available today:
• RFC-style draft with formal analysis
• Complete reference implementation (Node.js)
• Test vectors and collision probability analysis
This is early-stage protocol research, not a product. I'm looking for:
- Cryptographic review of the approach
- Feedback on the threat model
- Implementation critique
- Discussion on whether this future is worth building toward
GitHub: https://github.com/IAmAxolotl-04/password-smoke-detector
RFC Draft: https://github.com/IAmAxolotl-04/password-smoke-detector/tre...

value: Show HN: Building a future where security checks leave no permanent trails


value: ykhli

value:
Hi HN,
I built TetrisBench, a benchmark that tests LLMs on real-time code generation and reasoning through Tetris.
Live: https://tetrisbench.com/
*How it works:*
Each model starts with an initial optimization function for evaluating Tetris moves.
As the game progresses, the model sees the current board state and updates its algorithm—adapting its strategy based on how the game is evolving.
The model continuously refines its optimizer:
- Board getting too high? Prioritize clearing lines.
- Hole forming? Adjust penalties.
- Safe stack? Build for a Tetris.
The model generates updated code, executes it to score all placements, and picks the best move.
*Current standings:*
| Model | Win Rate |
|-------|----------|
| Opus 4.5 | 68% |
| GPT-5.2 | 63% |
| Grok 4.1 | 22% |
(181 games so far, running more)
*Try it yourself:*
You can also play against any model directly. See if you can beat opus at Tetris—only 1 human has so far.
*All trajectories are logged.* Every game saves board states, the code each model generated, and placement decisions. Happy to share the dataset

value: Show HN: TetrisBench – AI vs. AI vs. Human Tetris using realtime code generation

author: ykhli


value:
RLM-MCP – Analyze massive files in Claude Code using MIT's Recursive Language Models.
I built an MCP server that lets Claude Code analyze files that exceed its context window by implementing the Recursive Language Models approach from MIT (arXiv:2512.24601).
The problem: Claude Code can't fit a 10GB log file in its context. Traditional grep/read returns thousands of tokens of raw matches.
The solution: Instead of stuffing data into context, treat the file as an external environment. Claude writes Python code, the MCP server executes it on the full file, and only the results come back.
You: "Find all errors in this 5GB log"
Claude: loads file → writes regex → executes in REPL → returns matches
Result: 78% fewer tokens, same accuracy
Real benchmark (300KB log file):
  - Grep/Read: ~12,500 tokens
  - RLM: ~2,700 tokens
  - Both found identical results
No API keys needed – works with Claude Code subscriptions. Claude itself is the "brain," the MCP server is just the "hands" executing Python.
Install:
  pip install rlm-mcp

  Add to Claude Code settings:
  {"mcpServers": {"rlm": {"command": "rlm-mcp"}}}

  GitHub: https://github.com/ahmedm224/rlm-mcp
  Paper: https://arxiv.org/abs/2512.24601

Would love feedback on the approach. The MIT paper tested with GPT-5 and Qwen – this adapts it for Claude Code's MCP architecture

value: Show HN: RLM-MCP optimize context in Claude Code Using MIT's recursive LM paper


value: I been building a view into companies based on their job postings. I am hoping it is useful to get a quick snapshot on the company say for interview prep etc. Please be advised that it is still a WIP in terms of data quality. Example urls: https://jobswithgpt.com/company-profiles/openai/ https://jobswithgpt.com/company-profiles/advanced-micro-devi...

value: Show HN: Company hiring trends and insights from job postings


value: Show HN: A real-time poker chip tracker built as a PWA (No signup required)


value: alameenpd

value:
Hey HN!
I built UseWhisper.dev — an AI code reviewer that analyzes your code diffs, PRs, or snippets and returns review feedback instantly. It runs in the browser with no signup required, and is meant to give developers quick second opinions on logic, style, security, and best practices.
https://usewhisper.dev
What it does:
Paste a diff, GitHub PR link, or code snippet
Get line-by-line intelligent feedback
Suggestions on readability, errors, anti-patterns
No login, minimal UI, fast responses
Why I’m posting:
It’s still early and likely wrong in many ways. I want honest testing, brutal roasting, and real use-case feedback. Break it, trick it, embarrass it — everything helps.
Questions I care about:
Where does it give useful feedback vs hallucinations?
What common review suggestions does it miss?
UX friction when pasting diffs / navigating comments?
Danger points (wrong advice that would be harmful)?
Where should this fit in a real dev workflow?
If you tweet code at it, torture test async/edge cases, or compare with humans — post results!
Thanks for the heat

value: Show HN: UseWhisper.dev – AI Code Reviewer (please test and roast it)

author: alameenpd


value: sschotten

value:
Cloud billing is opaque by design. Each provider gives you an invoice optimized for their revenue recognition, not your capacity planning.
Run workloads across AWS, GCP, and Azure and you get three different billing models, three different SKU taxonomies, three different ways of saying "compute." Finance reconciles spreadsheets. Engineering guesses. Workload placement happens on hope.
I needed one view: footprint, cost, trend, forecast. Across vendors. Without paying $50k/year for a FinOps platform.
THE STACK
FOCUS (FinOps Open Cost and Usage Specification) normalizes cloud billing across providers. Ingest into TimescaleDB hypertable — handles millions of line items, months of data in gigabytes. Hasura for instant GraphQL endpoints. deck.gl for WebGL-accelerated visualization.
$50/month infrastructure. Few hours setup. Non-intrusive — just an API token for the FOCUS endpoint.
WHAT MADE IT USEFUL
Cost data alone doesn't tell you where to run things. So I added business context.
Bureau of Economic Analysis + Census integration: Direct API pulls for population and GDP by metro region. Auto-refreshed.
Latency Rings: Pick a region, set a threshold — say, 50ms. The viz shows how many people this workload can serve under that latency, and their GDP profile.
Now the question isn't "which region is cheapest?" It's "how many people can we serve under X ms, what's their economic value, and what does it cost?"
us-east-1 isn't the default because it's best. It's the default because nobody did the math. This does the math.
There's a "Reload data" button to flush from FOCUS APIs. Goal is 15-minute granularity — catch misuse on the fly, not in next month's invoice.
WHERE FOCUS FALLS SHORT
Commitment attribution — RIs and savings plans don't map cleanly to workloads. Tag hygiene — garbage in, garbage out. Network and egress — still a mess across providers.
---
The question that used to take a meeting: "How much are we spending in us-west-2 and how many users are we serving top-notch service?"
Drill down on the region, click a few buttons. Five seconds. Answer.
Demo: https://ure.us/atlas
I spent a few hours on this to solve a specific need. Turned out cooler than expected.
If there's interest, I'll open-source it — ingestion scripts, TimescaleDB schema, Hasura config, BEA/Census integration, latency ring logic, deck.gl dashboard.
Let me know.

value: Show HN: Multi-cloud cost visibility with latency rings and GDP data

author: sschotten


value:
I have been working on this experiment for quite some time and over the holidays I found sometime to polish things. I wanted to see if I can build a fully type-safe router, where everything from route params to search params was fully typed, even links.
My main inspiration came from Servant [1]
In Servant, you define a type-level API specification and then you use this type specification to:
- Implement a web server
- Generate client functions
I am still working on the API design and would love to get some feedback on the pattern.
[1] https://www.servant.dev/

value: Show HN: Schema First React Router

title: Show HN: Schema First React Router


value: lindsayhiebert

value:
HN users ask tough questions. Expect:
  - "How does the privacy actually work?"
  - "What's your tech stack?"
  - "Why $8.88?"
  - "Isn't this just a gimmick?"

value: Show HN: Red Horse Oracle – Privacy-first AI art, zero data stored

author: lindsayhiebert


value: justalever

value: Show HN: Rails UI

author: justalever

title: Show HN: Rails UI


value: can-deliktas

value:
Show HN: What I learned building a local-only password manager (PassForgePro)
Hi HN,
I built PassForgePro as a learning project to better understand password manager design, local-first security, and common cryptographic pitfalls.
The goal was not to replace mature tools like Bitwarden or KeePass, but to explore:
* how a local-only, zero-knowledge style design can work
* key derivation with PBKDF2 and encrypted SQLite vaults (AES-256-GCM)
* handling sensitive data in memory and clipboard cleanup
* defining a realistic threat model and its limitations
This project is experimental and unaudited. I’m sharing it mainly to get feedback on the architecture, crypto choices, and overall approach, and to discuss what I got wrong or could improve (audits, reproducible builds, testing, etc.).
I’d really appreciate feedback, especially from people with security or cryptography experience.
Repo: https://github.com/can-deliktas/PassForgePro
Docs / demo: https://can-deliktas.github.io/PassForgePro

author: can-deliktas


value: obsfx

value: Show HN: A minimal beads-like issue tracker for AI agents

author: obsfx


value: ninajlu

value: Show HN: SeeClaudeCode – visualize Claude Code's edits to your repo in real time

author: ninajlu


value: jaequery

value:
I built DockerHoster after getting tired of paying per-project hosting fees. It's a one-command setup that lets you host 20+ websites on a single $12/month VPS with automated GitHub deployments.
The problem: I wanted the simplicity of Vercel's "push to deploy" workflow but needed to run databases, cronjobs, and long-running processes that serverless platforms don't support well.
The solution: DockerHoster uses nginx-proxy to automatically route traffic to Docker containers based on VIRTUAL_HOST. You just copy a GitHub Actions workflow and docker-compose.yml to any project, and it deploys automatically on push.
What makes it different:
- Works with any language/framework (Next.js, Python, Rails, Go, etc.)
- Full Docker ecosystem access (PostgreSQL, MongoDB, Redis, AI vector DBs, etc.)
- No serverless limitations (cronjobs, SQLite, file system access all work)
- Tested running 20+ sites on a 2GB RAM DigitalOcean droplet
I personally prefer Cloudflare for SSL because you need DNS anyway, and it gives you free DDoS protection and WAF. For complex projects with multiple services, this is actually simpler than Vercel since everything lives in one docker-compose.yml file.
It's open source and I don't think hosting yourself can get much simpler than this (besides using platforms like Vercel, but then you don't control your infrastructure).
GitHub: https://github.com/jaequery/dockerhoster
Would love feedback and happy to answer questions!

value: Show HN: DockerHoster – Self-hosted alternative to Vercel with auto-deployments

author: jaequery


value: peaknk

value:
OP here.
 I got tired of writing manual wrappers for large APIs (GitHub, Stripe, etc.) just to get them working with AI agents. I found that stuffing 1,000+ endpoints into the context window usually leads to hallucinations or missing parameters.<p>> I built *JitAPI* to solve this by treating the API spec as a graph, not a list of tools.
> *How it works:*<p>> 1. It ingests a raw OpenAPI spec and builds a directed graph using *NetworkX*.<p>> 2. It detects dependencies between endpoints (e.g., recognizing that you need an `owner_id` from `GET /user` before you can call `POST /repos`).<p>> 3. At runtime, it uses *ChromaDB* to find the goal tool, then traverses the graph backwards to resolve the prerequisites automatically.
>
>
> It’s built as an *MCP (Model Context Protocol) Server*, so it works with Claude Desktop, Cursor, or any MCP client out of the box.
> The stack is Python, NetworkX, ChromaDB, and PydanticAI.
> Happy to answer any questions about the graph resolution logic—it's still experimental but handles the GitHub API surprisingly well.

value: Show HN: JitAPI – An MCP server that treats OpenAPI specs as dependency graphs

author: peaknk


value: pakosteve

value:
I'm a software tester since 2011. Become a Jira admin in 2013. Always wanted a tool which lives is inside jira and is a really cool test management app, where you can intuitively garden and execute your testing assets!
When I decided to give it a go in 2016, found a tool which was almost perfect, called Kanoah Tests. That tool went through a lot, and as of today become one of the biggest app in jira (zephyr). But I found that they lost their mojo and stopped innovating, so after some very hard years I decided to quit my job and build my brand new test management app, just as i dreamed about it! For now, its only available through jira as an app (free under 10 users, just as jira), but planning to release it as a standalone saas.
I started "development" with sonnet 3.7 and 4.0 which was terrible and slow. Used cursor 20$ and claude 20$ plans together with warp 20$ plan. Every time a model was free in cursor (grok, early gpt, anonymous) i used them in parallel for days or weeks, for maximum efficiency.
One day free gpt 5.0 introduced tanstack query because he thought it would be useful... :D
Honestly the app looked terrible, and design changed a lot on the way, especially I continuously kept up coming with new ideas which is a terrible practice! :D
Eventually Sonned 4.5 was a huge quality jump, so I subbed for 100$ claude, and was able to work 8-10 hours a day with it. Then they came out with opus 4.5 included in that plan, which was ... kind of exponentially better in all terms. So I worked even more, started to make bigger improvements and features on one shot, and It all worked. At the end I was helped by senior dev who reshaped infrastructure and some security stuff, but most of the app is created by agent, only me supervising them.
Curious what opus 5 will bring, and how the app finds its audience!
At least... I can use my dream test management app finally! :)

value: Show HN: I vibecoded a Test Management app for Jira

author: pakosteve


value: onatm

value:
Creator here. I built Snapbyte because I stopped having the time/energy to browse Hacker News / Reddit / Lobsters / Devto regularly, but I still wanted to keep up with things worth reading.
Snapbyte collects posts from multiple tech communities, filters them based on your interests, summarises them, and sends you a personalised email digest on a schedule you choose.
You can try it without creating an account (the homepage shows real example digests).
Some implementation details: Runs as a set of small services on my k8s cluster. Scraping via trafilatura. Summaries via gemini-3-flash-preview. Mix of TypeScript / Python / Go
Happy to answer questions, especially around scoring/filtering and what sources people would want next.
Note: if this post makes it to the HN front page, it’ll likely show up in Snapbyte digests tomorrow.

value: Show HN: Snapbyte – personalized email digests from HN/Reddit/Lobsters

author: onatm


value: jsafaiyeh

value: Show HN: Claude Skill for App Store Compliance

author: jsafaiyeh


value: mitjafelicijan

value:
Creator here. I made this little editor. It is rough around the edges. But why another editor? Well, I wanted to learn about this topic.
I had so much fun making it. It is a modal editor with some batteries included, like basic LSP integration, Tree-sitter for code highlighting (still limited, though), modal editing in Vim style (took some liberty with different remaps), and Ollama integration because why not.
This is still a work in progress, but I have been using it as my primary editor, and it perfectly fits my needs, tbh.
Happy to answer questions.

value: Show HN: Qwe – small, opinionated modal text editor

author: mitjafelicijan


value: aaatamas

value: The repo contains the code and analysis — feedback welcome.

value: Show HN: Exploring structure in a 1D cellular automaton

author: aaatamas


value: jsosville

value:
BizBuySell and similar marketplaces are closed, opaque, and full of duplicates. So I built an open-source, auditable ledger of business-for-sale listings.
Every record is source-linked, timestamped, and verifiable. If a listing can't be traced to its original source, it doesn't exist.
Think Wikipedia/EDGAR/OpenStreetMap for economic assets that are actually for sale.
Curious: Is this a useful public primitive? What would you build on top of it?

value: Show HN: DealGraph – an open, verifiable ledger of businesses for sale

author: jsosville


value: Mrakermo

value:
Hi HN,
I’m Eric, and I built www.meetgoran.com
Goran is a Mac/Windows desktop app for sales teams that turns your calls into actionable coaching: what was covered (and what wasn’t), what to improve next time, and patterns across reps.
First 5 meetings free (no credit card) ~ 10 min setup.
Connect Google Calendar so it can join scheduled meetings and capture the call context
What it does (practical, not “AI magic”):
- Produces structured sales notes + highlights key moments (pricing pushback, next steps, etc.)
- Scores calls against frameworks like MEDDIC/BANT (or your own checklist)
- Helps managers compare “top vs median” behaviors without rewatching hours of recordings
- Makes good examples searchable so new reps can copy what’s already working
Why I built it:
In most teams, the best talk-tracks stay trapped in recordings nobody rewatches, and managers don’t have time to coach every rep. I wanted something that turns calls into a “self-building playbook” reps will actually use.
What I’d love feedback on:
- Where would this not fit (team size, workflow, compliance constraints)?
- What should be the “default” output: rep coaching, manager dashboard, or team playbook?
Super happy with all responses.

value: Show HN: Automatically build sales playbook. For founders doing sales

author: Mrakermo


value: Bayram

value:
Hey HN! I built Retain as the evolution of claude-reflect (github.com/BayramAnnakov/claude-reflect).
The original problem: I use Claude Code/Codex daily for coding, plus claude.ai and ChatGPT occasionally. Every conversation contains decisions, corrections, and patterns I forget existed weeks later. I kept re-explaining the same preferences.
claude-reflect was a CLI tool that extracted learnings from Claude Code sessions. Retain takes this further with a native macOS app that:
- Aggregates conversations from Claude Code, claude.ai, ChatGPT, and Codex CLI
- Instant full-text search across thousands of conversations (SQLite + FTS5)
It's local-first - all data stays in a local SQLite database. No servers, no telemetry. Web sync uses your browser cookies to fetch conversations directly.

value: Show HN: Retain – A unified knowledge base for all your AI coding conversations

author: Bayram


value: toddynho

value:
Hey HN,
I built ChartKit, a lightweight React charting library for dashboards.
- 14 chart components (lines, bars, donuts, candlesticks, heatmaps, etc.)
- 17 curated themes (dark + light)
- ~15KB gzipped, zero dependencies
- Pure SVG, TypeScript-first
- LLM-ready with llms.txt for AI-assisted development
I built this because existing chart libraries are either massive (D3-based, 100KB+) or require tons of configuration to look good. ChartKit is designed to look polished out of the box.
Example:
```tsx
<LineChart
  data={data}
  series={[{ key: 'value', label: 'Revenue', area: true }]}
  theme="midnight"
  curve="monotone"
  responsive
/>
Live demo: https://chartkit.dev/demo
Docs: https://chartkit.dev
GitHub: https://github.com/toddynho/chartkit
npm: npm install @derpdaderp/chartkit
Would love feedback, especially on the API design and theme quality.

value: Show HN: ChartKit – 14 React charts in 15KB, zero dependencies, LLM-ready

author: toddynho


value:
Hi, creator here.
Most Raft/Paxos libraries treat the state machine as a black box. That’s fine until the state machine does real-world things like charging a card, sending an email or firing a webhook.
Then the leader crashes after the side effect but before commit, and you get duplicates. Every time. All the “exactly once” hand-waving collapses the moment a process dies mid-flight.
This repo is my attempt to fix that by design: side effects live in the replicated log, not behind it.
how it works, roughly:
Side effects are written as pending entries in replicated state. Only the current leader executes them, under a fencing token.
Leadership is fenced durably so a zombie leader can’t wake up and re-run old effects.
The state machine runs with a deterministic RNG seed + block time from the log, so replay is bit-for-bit or it halts.
The WAL is strict: CRC + hash-chained. Corruption stops the system instead of guessing.
Trade-offs are explicit:
Effects are at-least-once. Exactly-once requires stable IDs and sink-side dedup.
CP over AP. Safety over availability.
If you’ve ever been paged because a leader died at exactly the wrong microsecond, you know why I built this.
Repo: https://github.com/abokhalill/chr2
Happy to answer any questions about chr2 architectural internals or design trade offs.

value: Show HN: Consensus for Side Effects

title: Show HN: Consensus for Side Effects


value:
Hello HN folks- maker here,
I built Sornic because I have 100+ saved articles I never read. Now I listen to them while commuting.
How it works:
- Paste any article URL
- Mozilla Readability extracts content
- Claude Haiku cleans it up (removes "subscribe", ads, etc.)
- OpenAI TTS generates natural audio
Free to use, 5 articles/day, no signup.
Stack: Next.js, Upstash Redis, Vercel
What I'd love feedback on:
- Which sites don't work (so I can improve extraction)
- Voice quality preferences
- Would you pay for unlimited?
Thanks for trying it!

value: Show HN: Sornic – Turn any article into a podcast in 10 seconds


value:
I spent 15 years in FP&A and corporate budgeting. For the first 10, I actively avoided management because the path to leadership seemed designed for extroverts. Be more visible. Speak up in meetings. Network at happy hours.
I eventually got promoted anyway, mostly by taking ownership of problems I cared about fixing more than I cared about avoiding meetings. Turns out if you run the meeting, you can keep it organized.
Recently I taught myself to code using AI tools (Cursor + Claude, mostly) and wanted to build something that would have helped my past self. The result is leadquiet.com an AI coaching tool specifically for introverts in leadership roles.
It's text-based (no video calls), focused on energy management and leveraging introvert strengths rather than "overcoming" them, and priced for individuals ($15/mo).
I'm not from tech. I still work full-time in finance. Built this nights and weekends. Would love feedback if you try it.

value: Show HN: I built an AI coach for introverted leaders


value: liberian

value: Show HN: Local Unique Identifier – (LocalUID)

author: liberian


value: yetkinsal

value:
Hi HN! I built Rondinello because trip planning was frustrating -
whether solo or with friends.
For solo: Tell it your pace, budget, allergies → get a
day-by-day itinerary with insider tips.
For groups: Everyone submits preferences, AI finds consensus
(handles conflicting budgets, dietary needs, kids, mobility).
Features:
- Constraint-first: Allergies, wheelchair access, stroller-friendly
- Real place data from Google Places API
- Partner deals for hotels, tours, transport
- Works for "tonight dinner" or 2-week trips
Tech: Next.js 14, Supabase, OpenAI GPT-5.2
Free, no account needed. Would love feedback!

value: Show HN: Free AI trip planner that handles allergies,budgets and group consensus

author: yetkinsal


value: You can just read any Wikipedia pages like man page, also can search for articles.

value: Show HN: WIK v2.0.0 read Wikipedia as manual pages


value: todaycompanies

value: Show HN: AI-powered audits, analysis for Federal, Military, ICE, State

author: todaycompanies


value: connorboyle

value: Show HN: An Ishihara (colorblindness) test generator

author: connorboyle


value: frumu

value:
I built Tandem, an open-source desktop “AI coworker” that runs on Windows/Linux/macOS.
I wanted this workflow on Windows/Linux too (a lot of similar tools are macOS-first).
How it works:
Plan Mode: the assistant proposes a task list → you review → batch execute
Artifacts: generates shareable HTML reports/dashboards as real files in your workspace
BYOK models/providers: OpenRouter / OpenAI / Anthropic / Ollama
Repo: https://github.com/frumu-ai/tandem
Downloads: https://tandem.frumu.ai/
What should I demo next: web research refresh, legal research, or script studio?

value: Show HN: Tandem – open-source cross-platform AI coworker (Tauri)

author: frumu


value: mchristensen

value:
Hey HN,
Staff Engineer at Ably here. Over the past few months I've been speaking to engineers building AI assistants, copilots, and agentic workflows (over 40 companies at this point), with particular focus on cloud-hosted agents.
I expected the hard problems to be in model selection, prompt engineering, and orchestration. Instead, the same infrastructure challenges kept coming up: realtime sync between agents and end clients is surprisingly painful to get right.
- Managing and scaling WebSocket or SSE connections between agents and clients
- Buffering messages server-side and implementing replay logic for reconnecting clients
- Tracking what each client has received across multiple devices
- Ensuring continuity between historical and live responses on initial load
- Routing reconnecting clients to the correct agent instance in distributed deployments
Ably AI Transport solves this: it's a drop-in transport layer that sits between your agents and end-user devices.
We discovered many companies who were already using Ably Pub/Sub to tackle these problems. The pub/sub pattern decouples agents from clients: agents publish to channels, clients subscribe, Ably handles delivery and replay.
AI Transport makes this easier - for example, we've added message appends for efficient token streaming, and annotations for attaching metadata like citations.
A few of the interesting technical pieces:
- Channel-oriented architecture: In connection-oriented setups, the connection pokes the agent into life. If the connection drops, on reconnection the agent must figure out what state each client is missing. AI Transport uses channels instead: agents publish, clients subscribe, the channel handles replay. Presence events let agents detect when users go online/offline or connect from multiple devices.
- Identity in decoupled pub/sub: Users authenticate with your server, which issues JWTs with embedded clientId and capabilities. Agents receive messages with cryptographically verified identity. User claims (ably.channel.* in the JWT) appear in message.extras.userClaim - useful for HITL workflows where you verify an approver's role before executing a tool call.
- Token streaming with appends: New message.append operation lets you build a response incrementally. Clients joining mid-stream get a message.update with the complete response so far, then receive subsequent appends. Channel history contains one compacted message per response.
- Annotations for citations: Attach citation metadata to responses without modifying content. Clients can subscribe to individual annotations or obtain them on demand via REST. Ably also automatically aggregates annotations into summaries (e.g. count by domain name), which are delivered to clients in realtime.
- Messaging patterns: Docs include patterns for tool calls, human-in-the-loop approval flows, and chain-of-thought streaming.
Docs: https://ably.com/docs/ai-transport
If you're building AI UX, I'd love to hear what problems you've hit and what you've built in-house.
Thanks!
Mike Christensen

value: Show HN: Ably AI Transport - a transport layer for agentic apps

author: mchristensen


value: dsky

value:
Friend and me created a video game discovery website trying to answer the "what to play next" question.
Unlike most other sites we wanted to support every platform, so whether you look for something on your PC, Playstation, Switch or even your phone or browser you should find something.
We're still in the early stages and seek feedback  (especially on the https://gamebrain.co/what-should-i-play and https://gamebrain.co/recommendations flows).
Any well-meaning feedback is highly appreciated!

value: Show HN: Find what you should play next

author: dsky

title: Show HN: Find what you should play next


value: Show HN: PFAS Reporting 2026 – Triage tool for the EPA's 2011–2026 lookback rule


value:
I built infinate, an open-source (Apache 2.0) attention mechanism that places tokens in a 3D semantic space and
limits attention to ~50 nearest neighbors via exponential decay + hard cutoff. This gives true O(k) constant complexity:
latency ~7–14 ms and memory fixed (1.50 MB in production) even at 10M+ tokens on CPU.
Latest update (Jan 20, 2026): Milestone 1.11 – Strafe Jumping Navigation. As a longtime Quake player, I applied real game
physics exploits (7/9 validated) — bunny hop, circle jump, warp lanes, momentum accumulation, LOD hopping, etc. — to make semantic
traversal ultra-fast, like speedrunning in 3D space.
Benchmarks (all CPU, Qdrant vector store):
- In-memory mode:
  - CodeQA (100K): 3.57 ms vs MIT RLM 15,000 ms → 4,198× faster
  - OOLONG (500K): 4.06 ms vs 35,000 ms → 8,628× faster
  - BrowseComp+ (10M): 7.18 ms vs 120,000 ms → 16,722× faster
  - Average speedup: 10,317× vs MIT Recursive Language Models (arXiv:2512.24601)
- Production (Docker/Qdrant): Average 533× faster
- Memory: Constant 1.50 MB in container mode (62.2% less than in-memory; 10× tokens → 0.96× memory)
- O(k) scaling: 20× tokens → 2.85× time increase (vs 400× for O(n²))
- Cost: 1,330× cheaper than MIT RLM
Repo: https://github.com/ch1pu/infinate (Python/PyTorch backend, Qdrant/pgvector adapters, 369 tests @99.2% pass rate, 89.58% coverage).
GPU-native design (local neighborhoods suit warp parallelism) — Blackwell sm_120 kernels planned next.
I'm a solo dev (Navy vet, Uber driver, Quake player). The spatial 3D + physics-inspired navigation feels like an unusual but effective combo.
Does it hold up technically? Any obvious flaws, better ways to exploit the 3D space, or integration ideas with existing LLMs?
Curious for HN feedback — questions, critiques, suggestions welcome.

value: Show HN: Infinate –O(k)constant-time spatial attention for unlimited LLM context


value: oregoncurtis

value:
Google reviews piss me off because it's either 1 star or 5 stars and who knows if the person actually ate the food. I wish people had to visit a place multiple times, spaced out, before their ratings would even count. I decided to take that philosophy and apply it to one dish, Phở.
I'm going to all the restaurants that serve phở in Portland, Oregon's city limits and rating them. You can see the ranking, but not the point values until I've visited twice. Technically you can go get the data as it's open source and get the scores, but most people are too lazy to do that. It's a simple static site built with astro, so hammer away at what I did wrong.
I've been going in spurts over the past couple years and I'm hoping to get through the first round within the next month or two. I'm a white guy that doesn't know anything so of course the ratings are completely subjective.

value: Show HN: I'm eating at all the phở restaurants in Portland, at least twice

author: oregoncurtis


value: Show HN: Unicode Explorer – Explore, Search, and Learn Unicode


value: buildwithdep

value:
Hi HN,
I recently shipped a small MVP called ImproveThis, and I wanted to share the thinking behind it and get feedback from the community.
The core idea is simple: the same message can sound very different depending on who it’s sent to. A note to a manager, a colleague, or a friend often needs a different tone, even if the intent is the same.
ImproveThis lets users define people they commonly write to and refines text accordingly.
What’s interesting to me isn’t the AI part, but the product decisions around it.
I actually bought the domain back in May 2025, but between a full time job and personal commitments, I kept postponing it. Recently, I decided to stop optimizing for “perfect” and instead ship something usable and learn from real usage.
A few deliberate choices in this MVP:
- No pricing plans yet
- No payment integration
- One free plan with 100 refinements per month
- No credit card required
At this stage, I’m prioritizing usage patterns and feedback over monetization. I want to understand:
When people actually use this
Whether the “who you’re writing to” framing is helpful
What feels unnecessary or missing
I’m sharing this here because HN discussions tend to surface practical feedback that’s hard to get elsewhere.
Happy to answer questions about the product, the decisions behind it, or where I’m unsure. Feedback very welcome.

value: Show HN: ImproveThis, refine messages based on who you're writing to

author: buildwithdep


value: tonyystef

value:
Hi HN, I'm Tony.
I built Grov (https://grov.dev/) because I hit a wall with current AI coding assistants: they are "single-player." The moment I kill a terminal pane or close a chat session, the high-level reasoning and architectural decisions generated during that session are lost. If a teammate touches that same code an hour later, their agent has to re-derive everything from scratch or read many documentation files for basically any feature implemented or bug fixed.
I wanted to stop writing a lot of docs for everything just to give context to my agents or have to re-explain to my agents what my teammate did and why.
Grov is an open-source context layer that effectively gives your team's AI agents a shared, persistent memory.
Here is the technical approach:
1. Decision-grain memory, not document storage: When you sync a memory, Grov structures knowledge at the decision level. We capture the specific aspect (e.g., "Auth Strategy"), the choice made ("JWT"), and the reasoning ("Stateless for scaling"). Crucially, when your codebase evolves, we don't overwrite memories, we mark old decisions as superseded and link them to the new choice. This gives your team an audit trail of architectural evolution, not just the current snapshot.
2. Git-like branches for memories: Teams experimenting with different approaches can create memory branches. Memories on a feature branch stay isolated until you are ready to merge. Access control mirrors Git: main is team-wide, while feature branches keep noise isolated. When you merge the branch, those accumulated insights become instantly available to everyone's agents.
3. Two-stage injection (Token Optimization): The expensive part of shared memory isn't storage it's the context window. Loading 10 irrelevant memories wastes tokens and confuses the model. Grov uses a "Preview → Expand" strategy:
 Preview: A hybrid semantic/keyword search returns lightweight memory summaries (~100 tokens).
 Expand: The full reasoning traces (~500-1k tokens) are only injected if the agent explicitly requests more detail. This typically results in a 50-70% token reduction per session compared to raw context dumping.
The result: Your teammate's agent doesn't waste 5 minutes re-exploring why you chose Postgres over Redis, or re-reading auth middleware. It just knows, because your agent already figured it out and shared it.
Github: https://github.com/TonyStef/Grov

value: Show HN: Grov – Multiplayer for AI coding agents

author: tonyystef


value: mpaepper

value: Show HN: Matrix style morphing into ASCII art rendering of myself

author: mpaepper


value:
140M organic views on single video
2B views in 1 month that drives app installs<p>We built a viral video system to help B2C apps distribute on TikTok & YouTube Shorts.
We’re incubating small teams & solo founders.
DM me to apply

value: Show HN: A distribution-first incubator for solo and small-team B2C apps


value: TheDever

value: Show HN: Syntux - build generative UIs for the web.

author: TheDever


value:
hey all,
I work on a volunteer football committee and one of the areas where amateur clubs struggle in many cases is assessing the viability of teams.
Each season yes there will absolutely be teams that will get the numbers, but when clubs want to expand their reach (perhaps into new age groups, into new divisions) it can be difficult to easily gauge whether it is worth opening registrations and taking that risk.
Many of the registration tools clubs use do not offer the ability to have an expression of interest product, and instead only offer proper registrations including credit card payments up front so players have to pay to indicate interest. One could argue that means players are definitely interested, but its also a huge barrier to entry especially when its possible that team will not be viable.
This leads to situations where clubs may have to provide refunds and tell players they can't run the team that year. This leads to bad PR and of course nightmare accounting for the volunteer treasurers.
Squadsure closes this gap by offering the ability to post teams you are thinking of running, including the minimum number. It is low friction in that potential players only have to offer a name and email, to be kept up to date as to whether the team can go ahead.
It gives clubs custom pages listing the teams for expression of interest that they can easily share on social sites, emails, whatsapp etc.
Players can also see how close the team is to the goal and admins in the backend can export the data out to easily contact those players once the team becomes viable.
I built this because we had this very problem at our own club and I've seen it reflected in other clubs and sports as well.
It's designed to be easy to use, low friction and save time. Something that volunteer committees crave, because this is not their day job.
Give it a look and let me know what you think. I built this not to become a billionarie or even a millionaire, but to solve what to me seems to be a pretty obvious gap in sports registration software.

value: Show HN: Squadsure a free tool for volunteer sports committees


value: cjbarber

value: Show HN Guidelines

author: cjbarber

title: Show HN Guidelines


value: markyd

value:
I spent months building an app only to realize I had zero distribution. To solve this, I’ve manually vetted 40+ influencers (reach up to 160k) specifically for SaaS promotion.
The platform is live at ShipShared.link. We’re selecting our “Founding 10” startups for a February 9th pilot.
The Model:
• No Monthly Subscriptions: You don't pay a monthly fee just to access the platform.
• Fixed Campaign Fees: Founders pay a fixed fee to launch a campaign, which provides predictable reach.
• Verified Influencers: We handle the vetting so you don't have to "launch and pray."
I'd appreciate any feedback on the model or the site.

value: Show HN: ShipShared – Breaking the "distribution wall" for micro-SaaS

author: markyd


value: Show HN: TidyPython – Real-time syntax repair for Python


value:
Hey HN, we trained and open-sourced a 1.5B model that predicts your next edits, similar to Cursor. You can download the weights here (https://huggingface.co/sweepai/sweep-next-edit-1.5b) or try it in our JetBrains plugin (https://plugins.jetbrains.com/plugin/26860-sweep-ai-autocomp...).
Next-edit autocomplete differs from standard autocomplete by using your recent edits as context when predicting completions. The model is small enough to run locally while outperforming models 4x its size on both speed and accuracy.
We tested against Mercury (Inception), Zeta (Zed), and Instinct (Continue) across five benchmarks: next-edit above/below cursor, tab-to-jump for distant changes, standard FIM, and noisiness. We found exact-match accuracy correlates best with real usability because code is fairly precise and the solution space is small.
Prompt format turned out to matter more than we expected. We ran a genetic algorithm over 30+ diff formats and found simple `original`/`updated` blocks beat unified diffs. The verbose format is just easier for smaller models to understand.
Training was SFT on ~100k examples from permissively-licensed repos (4hrs on 8xH100), then RL for 2000 steps with tree-sitter parse checking and size regularization. The RL step fixes edge cases SFT can’t like, generating code that doesn’t parse or overly verbose outputs.
We're open-sourcing the weights so the community can build fast, privacy-preserving autocomplete for any editor. If you're building for VSCode, Neovim, or something else, we'd love to see what you make with it!

value: Show HN: Sweep, Open-weights 1.5B model for next-edit autocomplete


value: ddaras

value: Show HN: An unopinionated, Express-like framework for AI agents

author: ddaras


value: sunamic

value: I wanted a minimalist launcher that limits the apps I can access based on my location. I waste way to much time doom scrolling at home, and simply removing the app from my apps list based on my location has really helped.

value: Show HN: Haven – Anti Brain Rot Android Launcher

author: sunamic


value: justvugg

value:
Hi HN — I’m the author of PolyMCP (MIT).
PolyMCP is a toolkit/runtime for the Model Context Protocol (MCP): it helps you build MCP tool servers (expose Python functions as tools over HTTP/stdio), connect multiple MCP servers, and run agents that orchestrate them with deploy-friendly guardrails.
Latest update is mostly reliability work:
- OAuth2 (RFC 6749): client credentials + authorization code flows, refresh handling, basic retries
- Docker executor cleanup fixes (Windows + Unix)
- Better skills/tool matching + stdio server support
- CodeAgent async handling + error recovery
- Health checks, structured logging, and rate limiting
Repo: https://github.com/poly-mcp/Polymcp
If you’ve deployed MCP/agent systems: what tends to bite you first (auth, rate limits, observability, sandboxing)?
I’m especially interested in OAuth2 edge cases and container lifecycle issues.

value: Show HN: PolyMCP – open-source toolkit to expose MCP tools and run agents

author: justvugg


value: xinbenlv

value:
Hi HN,
I built this because I often work in coworking spaces or do screen sharing, and I've always had this fear of accidentally flashing my .env file with production secrets to the whole room (or recording).
It’s a simple VS Code extension that opens .env files in a custom grid editor. It automatically masks any value longer than 6 characters so I can safely open the file to check keys without exposing the actual secrets.
It runs 100% locally with zero dependencies (I know how sensitive these files are). It just reads the file, renders the grid, and saves it back as standard text.
It's open source (MIT) and I'd love any feedback on the masking logic or other features that would make it safer to use.
Marketplace: https://marketplace.visualstudio.com/items?itemName=xinbenlv...  Github https://github.com/xinbenlv/dotenv-mask-editor

value: Show HN: Dotenv Mask Editor: No more embarrassing screen leaks of your .env

author: xinbenlv


value: uulong

value: Show HN: QingMing – Exact vector search on consumer GPUs (no index)

author: uulong


value:
I spent the last few months watching LLM agents "vibe-code" their way into production disasters. We’ve been pretending that a 500-word system prompt is a security layer. It isn't. It's just a polite request that the model is one jailbreak away from ignoring.
I built Faramesh because I wanted a hard, cryptographic boundary between the agent's "brain" and my actual infrastructure. It intercepts tool-calls and forces them through a deterministic gate before any code runs. If the action isn't in your policy, it simply doesn't exist.
The biggest headache was canonicalization.py. LLMs are messy—one model sends a float as 1.0, another as 1.00, and it breaks the cryptographic hash every time. I wrote a normalization engine to ensure that identical intent produces the exact same byte-stream and hash.
It’s open source (Python/Node SDKs). I’m curious if people think this should live at the framework level or as a standalone proxy. Tear the code apart:
https://github.com/faramesh/faramesh-core
For theory lovers, I'd invite you to read a paper i published just recently titled "Faramesh: A Protocol-Agnostic Execution Control Plane for Autonomous Agent systems" (Link below)
https://doi.org/10.5281/zenodo.18296731

value: Show HN: Faramesh – A deterministic gate for stochastic Autonomous AI agents


value: jernestomg

value:
I'm building gluonDB to make data monitoring faster and more accessible for small teams.
Think Metabase meets Cursor: You connect your database and use an AI agent to ask questions in plain English. The agent generates the dashboards you can share with your team.
Status: We are in early beta.
- Support: Currently optimized for Postgres-compatible databases (Supabase, RDS, etc.).
All feedback is welcome, I’ll be here to answer questions about the tech or our roadmap.

value: Show HN: GluonDB – Cursor for Your Database

author: jernestomg


value: Show HN: HinkyPunk VPN

title: Show HN: HinkyPunk VPN


value: Show HN: imessage-data-foundry – Synthetic iMessage Data Generator


value: mrqjr

value:
I spent the past year solving a real problem: AI-translated subtitles are inconsistent—switching between formal and casual, character names changing mid-film, tone jumping around randomly.
Existing tools treat subtitles as isolated sentences. So I built a *multi-agent system* that works like a real translation team: a "director" creates a style guide for the entire film, a "glossary agent" enforces consistent terminology, and a "translator" works with context windows.
It works well. I've processed hundreds of hours of subtitles with it, and the quality beats most SaaS products I've tried.
Honestly, I originally wanted to build a SaaS. But getting a product noticed is hard—marketing, customer acquisition, support. As a solo developer, I don't have the resources of a big company or VC.
Rather than let this project die on my hard drive, I'm open-sourcing it so people who need it can deploy it themselves. At least this way, the time I spent isn't wasted, and it can help some people.
Three specialized agents work in sequence:
1. Director Agent - Reads the entire subtitle file and generates a style guide (tone, formality, addressing strategy). Uses long-context models to analyze the full script.
2. Glossary Agent - Extracts and enforces consistent terminology: character names (with gender inference for pronouns), locations, domain terms. Outputs a Markdown glossary embeddable in prompts.
3. Translator Agent - Uses a sliding window with bidirectional context:
   - References previous translations (for coherence)
   - Previews upcoming sentences (to avoid splitting errors)
   - Strict format validation (preserves timing, IDs, structure)
   - Batch processing for efficiency
4-6. Reviewer, Polisher, and Timing Adjuster agents are planned for Q1 2026.
Stack:
- .NET 10.0 + Microsoft Agents framework
- Subtitle Edit (libse) for parsing
- Multiple subtitle formats (auto-detection)
- Compact format to reduce token usage
- Configurable LLM endpoints (OpenAI-compatible, Gemini, etc.)
- Model strategy: Long-context for Director/Glossary, cost-effective for translation
Status:
[Y]Core pipeline (steps 1-3) is production-ready and open source
[Y]Monolingual translation works
[Y]Bilingual subtitle support available
Steps 4-6 Before Q2 2026
Windows/macOS/Web UI planned for May 2026

value: Show HN: Open-source multi-agent subtitle translator (self-hosted)

author: mrqjr


value: Show HN: StatechartX – performant state machine runtime written in Go


value: The Speaking Struggle: Every day you promise yourself you'll practice English, improve your pronunciation, finally become fluent. But life gets busy, you lack someone to practice with, and your confidence fades. You're not unmotivated - you're just tired of not having the right practice partner.<p>The EnglishCall Solution: What if practicing English felt like chatting with a supportive friend who never judges? Someone who adapts to your level, corrects gently, and celebrates your progress? Our AI doesn't just talk to you - it connects with you, guides you, and helps you speak with confidence.

value: Show HN: I built an AI that calls you and practices spoken English with you


value: decryption

value: My friends and I love putting stickers on our laptops, but most printing companies have a minimum order of a single design. I have a little hobby where I print and cut multiple single designs in one order at home and get great results. Perfect for folks who want to decorate and personalise their laptops!<p>You can get a dozen or so stickers for just AUD$20 (approx USD$14, €12, £10) and free worldwide shipping.

value: Show HN: Laptop Stickers – cheap individual short run stickers

author: decryption


value: quantbagel

value: I saw a tweet that tinygrad is so good that you could make a graphics library that wraps tg. So I’ve been hacking on a gtinygrad, and honestly it convinced me it could be used for legit research.<p>The JIT + tensor model ends up being a really nice way to express light transport all in simple python, so I reimplemented some new research papers from SIGGRAPH like REstir PG and SZ and it just works. instead of complicated cpp its just a 200 LOC of python.

value: Show HN: High speed graphics rendering research with tinygrad/tinyJIT

author: quantbagel


value: yeah, the readme is vibed, but the idea and the compression kept the whole session alive for like 30 minutes from start to finish with the HinkyPunk VPN. I'm sure there are improvements.

value: Show HN: Wisp: Stateful Claude Code Management


value: datalackey

value:
Unlike most tools that auto-generate Table Of Contents (TOCs) for a single
Markdown file, update-markdown-toc also supports:
– recursive TOC updates across all Markdown files within a folder hierarchy
– a --check mode for CI use, which only passes if all TOCs in all Markdown files
  are up-to-date with respect to the section headers in their respective files
Single-file operation is still supported, but the primary motivation for this
tool was repository-wide correctness in CI and build-system workflows.
Behavior is intentionally conservative:
– explicit start/end markers (no heuristic detection)
– deterministic output
– idempotent writes
– strict single-file mode vs lenient recursive traversal
Posting in case this is useful to others with similar workflows.
Repo + docs:
https://github.com/datalackey/build-tools/tree/main/javascri...
npm:
https://www.npmjs.com/package/@datalackey/update-markdown-to...

value: Show HN: Markdown TOC generator for JavaScript builds.Works recursively for repo

author: datalackey


value: hrudolph

value: Roo Code integrates directly with Slack to create an end to end agentic workflow. Start a discussion in Slack, get an actionable plan, modify the plan if needed, and then generate code all within Slack. You can preview changes, push to GitHub, and run tests without leaving your chat. Watch the video linked above for a full demonstration of how it works.

value: Show HN: Roo Code Slack: end to end agentic workflow in Slack

author: hrudolph


value: schappim

value: Show HN: Ekctl CLI for Managing Calendars and Reminders on macOS

author: schappim


value: nexuszero

value: Show HN: ERCOT Texas power grid dashboard

author: nexuszero


value: Show HN: FastPrintf – A zero-garbage, glibc-compliant Java formatter using Ropes


value: fetzdev

value:
I built a small service that turns docs.rs pages (and other documentation sites TBD) into clean, fully offline EPUB books.
I wanted an easy way to read Rust docs on an e-reader without losing structure or navigation.
I am aware of cargo offline docs... but it just doesn't quite hit the same, and does not view on my Kindle e-Reader. So, I built this to make sure I have my docs on-the-go when working on projects while traveling etc.
My workflow can be a bit strange, but for some reason having documentation available on my paper kindle is great for offline coding.
I've spoken with the Rust team who run's https://docs.rs and this tool is approved by them and fully respects their rate limits.
Feedback welcome. Github repo will be up soon, as I've decided on MIT open source licensing for the code. Maybe this won't be as useful or interesting to others as it is to me... but if it ends up being a hit... there's many more features that can be added of course!
Thanks for checking out my project! Fully prepared for the criticism bomb incoming :P

value: Show HN: Epub.rs – Library of Rust's Docs.rs pages converted to epubs

author: fetzdev


value: DCAlmond

value:
Hey HN!
I’m launching Desky, a social network inspired by Strava, but built for tracking work hours.
The idea is simple: if you can log runs and rides and get encouragement from friends, you should be able to do the same for focused work. A lot of meaningful work happens quietly, and I wanted a lightweight way to make it visible, trackable, and motivating.
What it does:
- Track daily work time + breaks, across different activity types (desk work, meetings, design work, spreadsheets, etc.)
- Follow friends and see a feed of their work sessions
- Endorse and circle back on sessions to keep each other accountable and motivated
- Track your shareholder value over time, as a single metric that reflects your consistency and output
Why I built it:
I started building Desky while living in an 8-person hackerhouse. One of my housemates stayed awake for 42 hours trying to resolve a bug. Watching that level of persistence made me realize there isn’t a great way to capture the effort behind work like that, or to support and encourage someone in the moment the way you can with fitness apps.
Desky is my attempt to bring that same kind of social motivation and progress tracking to work.
Who it’s for:
- People who want to measure and improve consistency without heavy project management tooling
- Friends/teams who want to stay accountable and encourage each other
- Anyone who likes seeing a clear record of where their time goes

value: Show HN: Desky – Strava style social tracking for work hours

author: DCAlmond


value: victoormt

value: Show HN: I used Veo 3 and Nano Banana to generate memorial videos for lost pets

author: victoormt


value: AmiteK

value:
Hi HN,
I built a CLI that extracts a deterministic, structured representation of a
TypeScript codebase (components, hooks, APIs, routes) directly from the AST.
The goal is to produce stable, diffable “codebase context” that can be used in
CI, tooling, or reasoning workflows, without relying on raw source text or
heuristic inference.
It supports incremental watch mode, backend route extraction (Express/Nest),
and outputs machine-readable data designed for automation.
Repo + docs:
https://github.com/LogicStamp/logicstamp-context
Happy to answer questions or hear where this would (or wouldn’t) be useful.

value: Show HN: Deterministic, machine-readable context for TypeScript codebases

author: AmiteK


value: This is a (silly, little) app which lets you make noise music using a color picker as an instrument. When you click on a specific point in the color picker, a bit of JavaScript maps the binary representation of the clicked-on color's hex-code to a "chord" in the 24 tone-equal-temperament scale. That chord is then played back using a throttled audio generation method which was implemented via Tone.js.<p>NOTE! Turn the volume way down before using the site. It is noise music. :)

value: Show HN: Synesthesia, make noise music with a colorpicker


value: bekacru

value: Show HN: Skill & MCP server for searching and retrieving 200k+ icons

author: bekacru


value:
Hi HN — I’m Kimi, founder of Aident AI.
A couple years ago, I cold-started a startup and tried to automate my outreach pipeline with a patchwork: RPA + Zapier + "just some ChatGPT".
It worked… until it didn’t. Every time I tweaked the strategy, the automation snapped. The system wasn’t built for change — it was built for wiring.
And that’s when it hit me: AI is finally smart enough to do real work, but we still don’t have a clean way to communicate the work to it: Drag-and-drop flows are too rigid; Scripts are too fragile; Prompts are too ephemeral. I kept thinking: why can’t automation be something you can simply read, edit, and trust?
So we built Aident around one idea: the source of truth is a document.
You write a Playbook in plain English (objectives, roles, handoffs), Aiden helps refine it, then we compile it into a reliable agent team (with built-in PM + QA roles) that executes skills with your 250+ tools (Gmail, Slack, Notion, Google Sheets/Calendar, GitHub, etc.). You can test it, schedule it, and then forget about it - it will keep delivering, even when you sleep.
It’s still early beta and can be bumpy sometimes, but I’d really appreciate you give it a try and let me know your feedbacks:
What workflow would you try first?
Where would this be a bad fit (compliance, data sensitivity, team size)?
What would make you trust it enough to run unattended?
Try @ https://app.aident.ai

value: Show HN: Aident, agentic automations as plain-English playbooks


value: hoag

value:
Hey HN! I'm a founder first, lawyer second. I understand code stacks well enough to explain them, but I've never been able to actually build software, and this has been a chip on my shoulder my entire life.
So Scribefully started as my first vibe coding project last summer. I'd read that building something with HN-style upvoting was a good learning project, and I was curious to try Claude Code.
The more I built, the more I realized I wanted what it evolved into: a single place to aggregate all my scattered professional work -– articles, papers, videos, code -– into one shareable page, with community upvoting baked in. Carrd and others offer portfolios, but none merge that with a social layer. Think HN meets a portfolio builder.
Example portfolios to check out:
  - https://scribefully.com/author/marc-hoag
  - https://scribefully.com/author/tawanda-kanhema
Browse everything without an account. Signup only required to comment or claim authorship. Completely free.
The hardest part was letting people use the site without signing up –- even submitting anonymously -– but claiming authorship later. This auth flow alone probably took 40-50 of my ~100 total hours. Race conditions are brutal, but of course you know that already.
Tech: Next.js 15, React 19, Supabase, Tailwind, Render. Built with Claude Code and ChatGPT Codex.
Side effect: I got so frustrated with context window issues (and secrets management) that I built this: https://github.com/marchoag/Claude-Code-Setup-Wizard-MD
I've shared Scribefully with academics and professionals since last July; figured it was time to Show HN.
Building this –- and an iOS app I shipped last week (FloodRoute for tracking flooded roads) –- has been kind of emotional. You can't imagine what it means to finally build software after years of only understanding it.
What a fantastic, magical time to be alive.

value: Show HN: Scribefully is a portfolio/HN-style community for academics & pros

author: hoag


value: twwch

value:
Hello HN,
I’ve been building AI agents lately and ran into a common "Context Bloat" problem. When an agent has 20+ skills, stuffing every system prompt, reference doc, and tool definition into a single request quickly hits token limits and degrades model performance (the "lost in the middle" problem).
To solve this, I built OpenSkills, an open-source SDK that implements a Progressive Disclosure Architecture for agent skills.
The Core Concept: Instead of loading everything upfront, OpenSkills splits a skill into three layers:
Layer 1 (Metadata): Light-weight tags and triggers (always loaded for discovery).
Layer 2 (Instruction): The core SKILL.md prompt (loaded only when the skill is matched).
Layer 3 (Resources): Heavy reference docs or scripts that are conditionally loaded based on the specific conversation context.
Why this matters:
Scalability: You can have hundreds of skills without overwhelming the LLM's context window.
Markdown-First: Skills are defined in a simple SKILL.md format. It’s human-readable, git-friendly, and easy for the LLM to parse.
Conditional Resources: For example, a "Finance Skill" only pulls in the tax-code.pdf reference if the query actually mentions tax compliance.
Key Features:
Python 3.10+ SDK.
Automatic skill matching and invocation.
Support for script execution (via [INVOKE:script_name] syntax).
Multimodal support (Images via URL/base64).
GitHub: [https://github.com/twwch/OpenSkills] PyPI: pip install openskills-sdk

value: Show HN: OpenSkills – Stop bloating your LLM context with unused instructions

author: twwch


value: michielme

value:
Built this because I was tired of writing the same watchdog boilerplate for file processing pipelines. FlowWatch is just decorators — @on_created, @on_modified, @on_deleted — plus a CLI and optional dashboard.
Main thing I needed was process_existing=True so it handles files already in the folder on startup, useful for recovery.
Using it for media workflows but it's generic. Feedback welcome.

value: Show HN: FlowWatch – Decorator-first file watcher for Python workflows

author: michielme


value: mattiaaleo

value:
I've been working on a question that kept coming up in audits:
How do you actually prove that logs haven’t been modified after the fact?
Most logging stacks (Splunk, Datadog, ELK) are great for analytics, but when auditors ask “how do you prove integrity?”, the answer is usually vague or procedural.
Spine answers this using cryptographic audit logs that can be verified offline, without trusting the logging system itself.
The SDK and CLI are now open source.
GitHub: https://github.com/EulBite/spine-oss
The problem
Recent EU regulations (DORA, NIS2) explicitly require tamper-evident audit trails, but the problem exists independently of regulation:
- Auditors increasingly ask how logs can be proven immutable
- Most companies I talked to had no concrete technical answer
Quick example:
from spine_client import WAL, WALConfig, SigningKey
key = SigningKey.generate()
wal = WAL(key, WALConfig(data_dir="./audit_log"))
await wal.initialize()
await wal.append({"event_type": "user.login", "user_id": "alice"})
Then verify offline:
$ spine-cli verify --wal ./audit_log
Status:              VALID
Events verified:     2,341
Signatures verified: 2,341
Chain integrity:     INTACT
No server required. An auditor can verify integrity without access to the system that generated the logs.
What’s open source
- spine-sdk-python – create signed audit logs locally
- spine-cli (Rust) – independently verify integrity
Apache 2.0 licensed
The server-side components (batch ledger coordination, timestamping, HA) remain proprietary.
Technical approach:
Each event → BLAKE3 hash → Ed25519 signature → append-only chain.
Instead of a single linear chain (where one corrupted entry invalidates everything after), Spine uses a batch ledger model: events are grouped into signed batches. A compromised batch doesn’t invalidate unrelated history.
Performance notes:
Benchmarks (Criterion, NVMe), included mainly to sanity-check overhead:
Signed + fsync: ~3,900 events/sec
Chain verification: ~537k events/sec
BLAKE3 @ 1KB: ~1.24 GiB/s
Benchmarks are included to validate design tradeoffs, not to claim absolute performance leadership.
Why open source the client?
Audit systems require trust. By releasing the SDK + CLI:
Anyone can verify the integrity claims
Audit data remains readable without our infrastructure
Independent security review of verification logic is possible
Looking for discussion
Happy to get feedback or be challenged on architecture choices, crypto primitives, or verification logic.
Repo: https://github.com/EulBite/spine-oss
Project page: https://eulbite.com/open-source

value: Show HN: Spine – Verifiable audit logs with BLAKE3 and Ed25519

author: mattiaaleo


value: txttosrt

value: Try on different short hairstyles virtually with AI. Upload your selfie and see yourself with Pixie Cut, Bob, and more from every angle. Perfect for anyone considering a new short hairstyle before visiting the salon.

value: Show HN: AI-Powered Virtual Haircut Simulator with 360° View

author: txttosrt


value: mikayelgr

value: Show HN: Qrystal Uplink – External watchdog for IoT fleets, setup in <5 mins

author: mikayelgr


value: themast

value: Show HN: How to stop Claude Code hallucinations using a CLI Truth Layer

author: themast


value: I’ve developed a simple AI-powered tool for transcribing podcasts. You can upload your podcast audio or video, and within minutes, it converts the episodes into clear, searchable text that you can edit, share, and repurpose. There is no need to download anything—everything runs directly in your browser.<p>I am primarily looking for feedback on transcription quality, user experience (UX), and any technical improvements worth exploring.

value: Show HN: A Free Online Podcast Transcription Tool


value: ishqdehlvi

value: Show HN: Best PG Management Software in India (HarGharPG))

author: ishqdehlvi


value: As someone who spends a lot of time interacting on X, I have spent so much time switching between keyword and mouse to look for and insert emojis.<p>This felt really slow and inconvenient, and I love the way messaging apps handle emoji autocomplete. So I added it to X as a Chrome extension, and called it Xmoji.

value: Show HN: I built a Chrome extension to add emoji autocomplete to X


value: Plarsy

value: Show HN: An accurate AI password guesser based on personal information

author: Plarsy


value: chrilleweb

value:
Hi HN
This is the documentation site for dotenv-diff
It’s a CLI tool that scans you’re codebase for environment variable usage in you’re codebase and detects issues about them.
Example: in Next.js using a non NEXT_PUBLIC environment variable in a client file just returns undefined - no context why.
I’ve personally wasted hours debugging issues like that.

value: Show HN: Environment variable scanner for JavaScript/TS projects

author: chrilleweb


value: Show HN: Crackable- a Cryptography CTF Platform


value: iqraathemanuel

value: TTS trained exclusively on public domain audio that runs on your computer, so there are no outages like cloud-based alternatives. Reliable, works across many different types of web pages including PDFs, with word-by-word highlighting, option to read any selected text, and auto-next page navigation which makes reading entire textbooks as easy as 1 click. I built this app because as a full-time college student I needed to read several different online textbooks and there was nothing that existed that could read all of them in natural voices reliably (massive internet outages as of late caused the only available voices to be robotic at certain times), not to mention the extra nice features I added on (and the more I plan to add in the future). Most TTS apps have a tradeoff between speed and audio quality, which is why they either need to be ran in data centers or sound robotic. BetterTTS uses extremely efficient processing to ensure you can run it on your own machine without making any compromises, resulting in 40+ natural sounding voices that can be ran on most consumer desktops faster than real time even when playing at 2.0x speed. You can skip ahead or skip backwards on a page (or skip between pages on PDFs) while it's reading by playing with the buttons on the bottom or by selecting any word and continuing from that exact point. It uses sophisticated logic (if you're interested, the reason it needs a dedicated native app instead of fully running in the browser is because the full model requires more memory than a browser is allowed to run in its sandbox) to ensure the audio chunk you want to play is always processed first so that it feels snappy no matter what. I poured my soul into this as a solo dev over the last 7 months while also being a full-time student in college so please give it a try and a review on the Microsoft store would be greatly appreciated. Any other feedback is also tremendously helpful and can be written here or sent to me directly at bettertts.help@gmail.com. There is a 1-week free trial to try out the app risk-free and if you don't cancel it, after that is a monthly subscription for $1.99 per month but this special launch sale offer ends on 2/28 so if you want to lock in that price forever you have to act quick (but if you cannot afford even this for a good reason you can email me and I may offer you a promo code to access it free for life with continuous updates free as well). By the way I am working on releasing a version for MacOS very soon which will take advantage of the Apple Silicon hardware to achieve even greater efficiency (up to ~11x faster than real time speed tested on my base M2 Mac Mini, with the exact same audio quality)

value: Show HN: BetterTTS – Offline Lifelike TTS Web Reader for Windows

author: iqraathemanuel