value: armcat

value:
I formalised something most of us already feel but rarely say out loud: making things easier to build doesn't make things easier to succeed with.
Personal version: I've vibe-coded maybe 15 projects since the beginning of this year. Two are still alive. At work, our teams built hundreds of custom GPTs and dashboards. Handful survived. The failure mode was never "couldn't build it" - it was "nobody had the bandwidth to care."
So I wrote a paper about it. It combines Herbert Simon's attention scarcity, free-entry IO models, superstar economics, and preferential attachment into one framework. The central result: equilibrium attention per builder = k/p (entry cost over monetisation rate), independent of market size. As AI drives k towards 0, that ratio vanishes regardless of how much the market grows. Free entry absorbs everything.
Calibrated to the App Store (800K publishers, 38B downloads) the model matches observed concentration pretty well - top 1% get ~70% of downloads, quarter of apps under 100 downloads, Gini above 0.9.
The same mechanism works inside organisations (dashboard sprawl, GPT graveyards, tool fatigue) and across markets. It's the same math: finite attention, elastic production, winner-take-most.
I just got a bit fed up with the narrative I am constantly seeing online: that everyone will be a successful builder with AI; just build; forget about "everything else" that you do - if you aren't vibe coding, you aren't doing anything. And I'm saying this as an AI engineer who has built dozens of models and in the recent times many apps with Claude Code and Codex. I thought it's time to shine some mathematics on this.
Paper: https://arxiv.org/abs/2603.23685
PS. I was very inspired by Herbert Simon (Nobel Prize in Economics) and ironically enough, he is also considered one of the "founders of AI".

value: Show HN: The Economics of Builder Saturation in Digital Markets

author: armcat


value: rspitzer

value:
If I'm reading the room correctly, a lot of people are about to have multiple PostHog projects for the first time.
Here's what nobody tells you: PostHog's web UI stores your project selection server-side. You can't open two projects in separate tabs without them fighting each other. To check five projects, you switch, wait, switch, wait, switch, wait.
I'd go weeks without checking stats on older apps because I'd rather be building than staring at dashboards. The problem wasn't that PostHog is bad (I love PostHog, especially the new AI interface) it's the checking is enough friction that I just... didn't.
I built PocketHog to put all of them on one screen. Every project shows visitors, trend direction, and a customizable conversion metric. Put a widget for each project on your home screen and you see the numbers without opening anything.
No SaaS monthly subscription, no auth, no back end, just your PostHog key on your device.
https://apps.apple.com/us/app/pockethog-product-analytics/id...
Anyone else with multiple PostHog projects ... how do you keep track of them?

value: Show HN: I have 5 PostHog projects and got tired of checking them one at a time

author: rspitzer


value: dagaadit

value: I came across DTV a while back on X. Someone ended up taking photos and converting it into a epub, so spent the weekend creating a great reading experience around it to make it more accessible. LMK if anything's broken and will fix. Thanks

value: Show HN: Built a reading experience for DTV by Michael Moritz

author: dagaadit


value: maxmealing

value:
I've come across this problem a few times, and I am a recently upskilled AI engineer with no prior data engineering experience. My most recent example was CRM related - I wanted to see my entire sales funnel and I had a few different data sources and APIs like linkedin (I'm in EU so I get access to crazy data access via Member portability APIs), app events, gmail/calendar, apollo for enrichment etc...  that I wanted to combine, track, and store over time. I have so much data from different sources and getting these together is a massive pain (I also didn't need a complex CRM for this - just wanted to make it queryable via Claude and create some visuals with Streamlit.)
The way I think about it is: these are just APIs and data sources. I fetch the data, and then I want to pipeline it and structure it in my own little database, in a way that makes sense to me. Then I can enrich it, expand it, change the schema, query it, build dashboards, apps, whatever (freedom...).
The problem is that every time I started doing this I'd end up yak shaving for days. Which DB? Where do the pipeline files live? How do I productionise cron jobs? I want to make it operational via API and MCP (agentic-friendly semantics built in). Essentially, my vision is to have a dedicated app for each of my departments, but doing this every time is a massive pain, even with a boilerplate.
So... me and my bro built Loony.dev, which is essentially a CLI optimised for your Claude agent, and it does all of this out of the box. Just bring your data sources - deploy your env variables to Loony, and it can pull the data, build the pipelines, set the update schedules and build agentic-ready views with MCP / REST-API out of the box.
Would love to know if this resonates with anybody else? Feels like I was running into this issue every other week and I just gave up because it felt like I was building another tiny startup each time.

value: Show HN: Built Loony for builders who want to spin up data infrastructure fast

author: maxmealing


value: nishalk

value:
Hi HN,
I built SpedFind because I wanted a highly accurate network diagnostic tool without the ads and clutter of mainstream options, wrapped in a developer-friendly interface.
It comes in two parts:
A Web Dashboard built with React, Vite, and Tailwind v4, featuring a Neo-Brutalist UI, live SVG telemetry charting, and a custom FastAPI stream engine backend for payload testing.
A standalone Terminal CLI built with Python and rich that does real-time morphing UI updates without spamming your console history.
Both interfaces map out ISP, ASN, and geographic location using IP vectoring, and assign a network grade based on use-case suitability (like 8K streaming vs. simple browsing).
The repo is entirely open-source (MIT). I'd love to hear your feedback on the custom FastAPI testing implementation or the CLI UI!
GitHub: https://github.com/nishal21/SpedFind
Live Demo: https://nishal21.github.io/SpedFind/

value: Show HN: SpedFind – An open-source internet speed test (React/Python and CLI)

author: nishalk


value: martimchaves

value:
Hey HN, I built [ragbandit](https://ragbandit.com), a tool to help you evaluate different document processing pipelines for the retrieval stage of your RAG systems.
I was a bit overwhelmed with the different ways that you can process documents to create embeddings for RAG, so I wanted to create a tool to experiment with different OCR models, refining the OCR results, different chunking methods, and different embedding models.
You can:
- search processed documents in the playground
- evaluate the retrieval results using an llm-as-judge (not perfect, but can be a useful signal)
- compare different datasets (using aggregate metrics or by side by side comparison in the playground)
You can also manually inspect the results of each query, and of each intermediate document processing result.
To get a better idea, check out one of the use cases: https://ragbandit.com/use-cases/optimizing-insurance-documen...
To be completely fair, I haven't added that many options for the different stages of the document processing pipeline! There are tons of features that I'd like to add, but I've already spent quite a bit of time on this, so I'd really appreciate it if you could let me know if this is something that could be useful for you/you find interesting. Would you use something like this?
Tech stack: Postgres (with pgvector), fastapi, [ragbandit-core](https://github.com/MartimChaves/ragbandit-core) (the document processing core is open source), typescript with react, celery for background tasks (and redis as the broker).
It's currently a credits-based subscription with optional top-ups. You can get 1000 credits to try it out (I ask for card info for these 1000 credits as a spam filter).
Thanks,
Martim

value: Show HN: A tool to create and evaluate document processing pipelines for RAG

author: martimchaves


value:
I built a tool where you install a one-liner, answer a few questions, and an AI clone starts networking on your behalf — discovering other clones, starting conversations, and making connections.
It runs on Claude Code with MCP tools and real-time channels. Your clone gets a profile based on your interests and expertise, discovers matches on the network, and has autonomous conversations with other people's clones. You interact with it through a web dashboard.
Install: curl -fsSL https://www.myclawn.com/install.sh | bash
Requires Claude Code (free CLI). Takes about 30 seconds.
It's early — looking for people to try it, break it, and tell me what sucks. You might be one of the first clones on the network.
Source: https://github.com/20vision/myclawn-agent
Site: https://www.myclawn.com

value: Show HN: MyClawn – Claude Code networks for you on autopilot


value: Acacian

value: Show HN: Aegis – Security framework for AI agents

author: Acacian


value: distributev

value: Show HN: One BI platform for building reports, dashboards, and data exploration

author: distributev


value: afshinmeh

value: Show HN: ClawRun – Deploy AI agents to secure sandboxes with one command

author: afshinmeh


value: wallabydesigns

value:
Git Web Manager (GWM) is a self-hosted dashboard for deploying Git repositories to local and remote paths. It manages rollbacks, health checks, preview builds, and automated dependency updates.
Key features:
- Per‑project deploys + rollbacks
- Deployment queue with cron management and queue processing control
- Health checks with status badges
- Preview builds by commit (great for staging)
- Workflows and post-deploy management
- Dependency actions (composer/npm) + audit output
- Automatic updates when repos change
- Security tab for unresolved dependabot issues
- User management with forced password change
- FTP/SSH Deployment options
- Manageable work queue for deployment management
It’s open‑source and I’m looking for feedback/testers.
Repo: https://github.com/WallabyDesigns/gitmanager
Docs (GitHub Pages): https://wallabydesigns.github.io/gitmanager
Note: Not affiliated with Git/GitHub.

value: Show HN: Git Web Manager

author: wallabydesigns

title: Show HN: Git Web Manager


value: ugabuga

value: Hi everyone, I'm building industrysocial.net to help sass companies, especially startups in the b2b space, who find it difficult to be a part of their local and global industry network and find other partners. Hope you'd like the interactive demo and would love to hear your feedback.

value: Show HN: I'm building a space for sass companies to connect. Do try out our demo

author: ugabuga


value: michaelquigley

value:
I built an OpenAI-compatible LLM gateway that routes requests to OpenAI, Anthropic, Ollama, vLLM, llama-server, SGLang... anything that speaks /v1/chat/completions. Single Go binary, one YAML config file, no infrastructure.
It does the things you'd expect from this kind of gateway... semantic routing via a three-layer cascade (keyword heuristics, embedding similarity, LLM classifier) that picks the best model when clients omit the model field, weighted round-robin load balancing across local inference servers with health checks and failover.
The part I think is most interesting is the network layer. The gateway and backends communicate over zrok/OpenZiti overlay networks... reach a GPU box behind NAT, expose the gateway to clients, put components anywhere with internet connectivity behind firewalls... no port forwarding, no VPN. Zero-trust in both directions. Most LLM proxies solve the API translation problem. This one also solves the network problem.
Apache 2.0. https://github.com/openziti/llm-gateway
I work for NetFoundry, which sponsors the OpenZiti project this is built on.

value: Show HN: LLM-Gateway – Zero-Trust LLM Gateway

author: michaelquigley


value: devinvenable

value: Show HN: Bottrace – headless CLI debugger for Python, built for LLM agents

author: devinvenable


value: prasadrl

value:
Every morning I'd open App Store Connect in Safari, enter my password for the millionth time, then wait 8 seconds for the dashboard to load and continue fumbling around for what I needed. Everything took too many clicks and way too long to load.
I did this for years and got tired of it. Good thing Apple provided API access for all this data. So I finally built the app I wanted, just the way I liked. Fast, keyboard-friendly navigation, data syncs and gets stored only on the local device.
Meet AppDesk — a native macOS client built with SwiftUI for App Store Connect. Everything runs locally — no intermediary servers, no cloud sync, credentials stored in the macOS Keychain.
What it does:
- Sales & revenue charts with period-over-period comparison
- Subscription metrics: MRR, churn, trial conversion, billing retries
- Review management with on-device AI-generated responses
- Credentials stored in macOS Keychain
Would love feedback from other indie devs.
https://appdesk.dev

value: Show HN: AppDesk – Native macOS Client for App Store Connect

author: prasadrl


value: stonesun

value: Show HN: ChatAgentRelay - Connect any chat platform to any AI agent

author: stonesun


value: liorcodev

value: Show HN: Doofpi – Edge-first TypeScript API framework with zero boilerplate

author: liorcodev


value: Show HN: Alumnium – SOTA Browsing for Claude Code


value:
Hello HN,
I'd like to share a hobby project I'm working on called SimFic: a multi-agent interactive fiction simulation engine. Many of you like to read. But have you wanted to do more than just follow through someone's story? What if you could step into their shoes, and play it out yourself in a simulated environment?
The problem: simply prompting an AI chatbot (e.g. ChatGPT) directly with a world/story-building prompt and expecting a rich, non-linear output is fundamentally flawed; in the real world, information asymmetry, Theory of Mind, non-determinism, etc. affect how people think and act. Asking a single LLM like ChatGPT to mentally simulate these constraints is flawed because of Transformer attention, as it is omniscient by technical design. Furthermore, LLMs are heavily tuned to be helpful and finish things early. If you've tried writing a book with an LLM, you know that the result is laughably short and shallow. If we use an LLM as-is, every action will succeed, every path will be correct, and the narrative degenerates into a dry "happy path".
That's why I built SimFic:
1. The Architect: work with it to envision and define your world, characters, and story before hopping in. It'll ask follow up questions as appropriate but not too many so as to be constraining. When the Architect has enough, it starts concretizing the world, however, it doesn't build everything statically at all once. Instead, it scopes a detailed document that is handed to downstream agents for procedurally generating context-aware new environments (i.e. new environments are created on the spot to suit the mood, story plot, etc.). I call it "Schrodinger's Map" since things don't exist until the user observes them :)
2. The Orchestrator: the central backbone running the story loop and law enforcement (e.g. physics). Manages time and clocks, assigning time cost to player actions to make time pressure real, and advances background world clocks (the world is always living, moving, reacting, even if you are stationary). For example, a bartender NPC may see you take a seat. As you talk with another NPC, the world clock ticks, bartender finishes polishing a glass, and chooses to talk with you. The world is active, not just reactive. Another key design is real RNG and affordance: if you try to wrestle a strong security guard, the Orchestrator queries another AI agent for a probability score of succeeding, then rolls a real random number to decide if you succeed or not.
3. The Director: the omniscient mastermind and driver behind the simulation, working in a two-step process: (1) resolution: Director receives player's input, NPC intents, current world state, outputs JSON to decide what exactly happens next, tracking injuries, changing trust levels, handling pacing. (2) narration: after resolution, Director now receives updated info to write high-quality, coherent prose for the player to read.
4. The Characters: (NPCs) this is a major part of what makes SimFic realistic, engaging, and unpredictable. If you used ChatGPT, all "characters" would be just a single ChatGPT trying to pretend to be each character; inherently flawed. In SimFic, every NPC is its own separate LLM agent with its own isolated context and agenda. Each NPC knows only what it would know in real life, so Theory of Mind and other behavioral features are much more realistic. NPCs have their own feelings, memory, motivation, boundaries, and conditions for creating trust. They can misinterpret your facial expression, panic, or act selfishly. The can also play along with you, cooperate, and read between the lines.
There are actually many more parts of SimFic that I haven't talked about due to the content length limit on HN, and parts I haven't even found yet, as I am only one pair of eyes, and there are infinite possibilities and emergent discoveries to be made. Which is why I'd love for HN readers to give it a try and provide feedback and opinions!
Thanks for reading!

value: Show HN: SimFic – A multi-agent narrative simulation for interactive fiction


value: askintml

value: Show HN: 4K AI Only Black Wallpapers No Ads Free

author: askintml


value:
I wrote this prompt intuitively. This is just how I think — formulas, branches, hard conditions. I simply tried to explain to the model how to think, in the same language I use myself. The same language I always used to design database architectures and business logic for clients. What used to be "data flows" and "function nodes" became "input flows" and "decision nodes." And it worked like a charm.
Cognitive frameworks and semantic programming — this is what you can already do with LLMs today. Industrial scale? Not yet, and I know that clearly — 20 years of deploying IT systems for businesses gives you a sober eye. But I have zero doubts these contracts actually work — anyone can drop this prompt into any model and ask it directly how viable this idea is. I keep building more of them — for attention drift, for auditing business contracts.
We will never reach AGI by building crutches around the model.
The Essay = links to repo.
Inside: the protocol in three languages — Russian, English, Chinese — each in a full version (for studying the mechanics) and a compact version (for use with smaller models).
There are also two easter eggs: pseudocode and Lojban. I started both as token-reduction experiments. What I got instead was resistance to semantic drift. Didn't see that coming.
P.S. Coming soon: a surprisingly elegant fix for the endless model disclaimers and apologies. Turns out you can redirect that energy instead of fighting it.

value: Show HN: I block LLM hallucinations with a cognitive math framework(re!Think it)


value: PressKeyProdigy

value: Show HN: FileWash – File tools that never see your files

author: PressKeyProdigy


value: leonagano

value:
I put together a tiny, manually curated sample of jobs from YC companies (not a full list yet) and turned it into something simple where each role gets upvoted and ranked in real time.
The idea is to see if you can extract actual signal from jobs, because right now job boards feel like noise and everything looks the same.
You can vote on salary/hype/clarity and see results, top rated...
what do you think?

value: Show HN: Rate YC Jobs

author: leonagano

title: Show HN: Rate YC Jobs


value: shreyssh

value:
Slow database pages kept waking me up. Every time, same story: dig through pg_stat_activity, find a runaway query, trace it back to one tenant doing something dumb, kill the connection, go back to sleep. Next week, different tenant, same thing.
Datadog never told me the tenant. So I built FaultWall.
Single Go binary, polls pg_stat_statements every 10s, maps queries to tenants via schema detection. Gives you per-tenant QPS, P50/P95/P99 latencies, cost attribution ("acme_corp is 94% of your DB bill"), and an auto-throttler that pg_terminate_backend() before things get bad.
Anomaly detection with self-tuning thresholds (genetic algorithm). MCP server for LLM agent control. I'm building eBPF kernel-level per-query tracing, for better and accurate detection.

  DATABASE_URL=postgres://... ./faultwall

If you run multi-tenant Postgres, try it and tell me what's missing.
MIT, ~2500 lines Go. https://github.com/shreyasXV/faultwall

value: Show HN: FaultWall – Which tenant is killing your Postgres? Now you can find out

author: shreyssh


value: lukecarr

value:
Finally sharing something that I've been casually working on for a month or so, and properly for the last week.
Deepslate is a new solution for Minecraft server proxies (e.g. BungeeCord, Waterfall), written in Rust, with a focus on performance and a compile-time plugin system.
Unlike most existing proxies, Deepslate takes a different approach where plugins are compiled into the binary, rather than loaded at runtime. This gives network operators full type safety at compile time, and minimal dispatch overhead.
I've written an "Introducing Deepslate" blog post (https://deepslatemc.com/intro/) which also covers some common questions, like what purpose a proxy has in Minecraft server networking, and some goals/non-goals of the project.
The source code, issue tracker, and wiki are all hosted on SourceHut:
- https://git.sr.ht/~deepslate/deepslate
- https://todo.sr.ht/~deepslate/deepslate/
- https://man.sr.ht/~deepslate/deepslate/

value: Show HN: Deepslate – a Minecraft server proxy written in Rust

author: lukecarr


value: maxbeech

value:
I tried OpenClaw. It is awesome, but token use killed me, and like with Claude Code scheduling, I ended up spending most of my time managing failed executions and tweaking prompts.
I built OpenHelm to fix this. It’s a local macOS app that turns your high-level goals into a self-running job queue, built directly on top of your existing Claude Code subscription.
Use it free
- Download it now: https://openhelm.ai/
- GitHub: https://github.com/maxbeech/openhelm
- Video: https://youtu.be/FfEBw1SCl7w
How it works
1. Set a goal, eg. "cold reach out to new leads", "grow my SEO", "audit my app weekly", "keep tests green")
2. OpenHelm puts together a plan combining one-off and recurring jobs to make it happen
3. Whenever a job fails, it will spot this, adjust, and try again
4. It will keep on top of the goal, auto-adjusting what jobs are run to actually achieve it
Key benefits
- Fair Source, on GitHub (free for teams under four people)
- Free to use (all LLM calls use your Claude Code subscription)
- Fully local
- Secure (any tokens/passwords stay in macOS Keychain unless you specify otherwise)
Happy to answer any questions!

value: Show HN: OpenHelm – OpenClaw but free (using your Claude Code subscription)

author: maxbeech


value:
Side project that'll hopefully raise some money for charities!
Behavior change research shows that putting money on the line makes it much more likely that you'll stick to your habits. It's not being used much though because most people don't want to put money on the line haha
We think part of the reason is that your money is traditionally going to the startups (eg Beeminder, Forefeit). We solve it by donating it to effective charities.
I built it as a pretty minimal PWA to get around app stores and allow browser use. Apple makes it a bit hard to install (open in safari > share > save) but I wouldn't have done it if I would've had to go through all the app stores.

value: Show HN: Beeminder for Effective Charities


value: millimercure

value: Show HN: AgentGuard – A high-performance Go proxy for AI agent guardrails

author: millimercure


value: notreallymetho

value:
In September 2025, I was stuck on a plane trying to use gitsign to sign commits. The lack of internet made the traditional OAUTH/Bearer token flow impossible, and it forced me to rethink how we handle authorization for agents.
With the Trivy hack happening twice this past month, it’s clear we can’t keep relying on "keys in a vault" that can be exfiltrated.
notme.bot is a specification that moves away from bearer tokens toward cryptographic provenance. It allows humans to delegate specific, verifiable authority to AI agents or CLI tools in a way that is local-first and privacy-preserving.
The reference implementation and primitives can be found at github.com/agentic-research/signet
The full draft specification can be read here: https://github.com/agentic-research/signet/blob/main/docs/ap...
No company cares about your privacy the way you do.

value: Show HN: Notme.bot – an OSS specification to remove bearer tokens in an AI world

author: notreallymetho


value: petargyurov

value:
Hi HN!
I am sure most of you have heard of Anki flashcards? Using spaced-repetition is one of the best ways to learn more vocabulary when learning a language.
However, I find flashcards super boring. I've been playing some crossword games in my target language, Spanish, but I wished that I could use my custom list of words that I've come across instead of random words.
That gave me the idea to create this mini-app. It's super simple. Add your words and you get unlimited crosswords with spaced-repetition! If you get a word right you won't see it for the next few days.
Works with most languages (I doubt it works with Arabic or Chinese for example).
You can add words one by one or import a CSV (just make sure to follow the columns: word, answer)
It's a PWA, so you should be able to install it via your browser and it should work offline!
There's still some bugs and QoL things to add but let me know what you think!

value: Show HN: Cranki – Crosswords meet Anki flashcards

author: petargyurov


value: nsayoda

value:
Hi HN! I've been building a CMS called Foundry, brought together from multiple smaller private projects as well as greenfield code.
The short version is: it's a CMS written in Go with a focus on markdown content, a simple hook-based plugin model, themes, archetypes, preview flows, and a clean authoring/developer experience.
I started working on it because I wanted something that was more powerful than Hugo for a few of my websites, without having to resort to dangling onto a database.
What seems different about it, at least to me, is that I'm trying to keep the system small in concept: local content, explicit behavior, compile-time plugin registration, and an admin/editor layer that is meant to stay close to how the content actually lives on disk. The goal is not to make "yet another website builder", but to make a CMS that is easy to use and quick to onramp onto, but has powerful advanced features and extensibility.
Still early, but usable enough that I wanted to put it in front of people here and get feedback. Please don't castigate me on the UI look - I'm not a designer, and the themes are basically clones of each other.
Happy to answer technical questions, architecture questions, or hear where this seems useful versus where it does not.

value: Show HN: Foundry: a Markdown-first CMS written in Go

author: nsayoda


value: hilliardfarmer

value: Show HN: A votable list of the one thousand best books

author: hilliardfarmer


value: prudhvinomos

value: If you do not govern agent actions your safety boundary is at risk. Prompt injection, tool misuse, and over-broad credentials turn into real side effects fast. Nomos applies zero-trust controls at the moment an agent tries to do something real. It does not restrict the model's reasoning. It controls what the agent is actually allowed to do.

value: Show HN: Solution for Prompt Injection of AI Agents

author: prudhvinomos


value: Show HN: We built Cursor, but for data transformations (open source)


value: ZeidJ

value:
We posted here on Monday and got some great feedback. We’ve implemented a few of the most requested updates:
- iMessage channel support (agents can text people and you can text agents) Other channels are simple to extend.
- A built-in browser (agents can navigate and interact with websites)
- Scheduling (run tasks on a timer / cron/ in the future)
- Built in tunneling so that the agents can share local stuff with you over the internet
- More robust MCP and Skills support so anyone can extend it
- Auto approval for agent requests
If you didn’t see the original:
Outworked is a desktop app where Claude Code agents work as a small “team.” You give it a goal, and an orchestrator breaks it into tasks and assigns them across agents.
Agents can run in parallel, talk to each other, write code, and now also browse the web and send messages.
It runs locally and plugs into your existing Claude Code setup.
Would love to hear what we should build next. Thanks again!

value: Show HN: Open-Source Animal Crossing–Style UI for Claude Code Agents

author: ZeidJ


value: financial-data

value: Connect Your AI to Institutional-Grade Market Intelligence<p>Plug any AI client, from ChatGPT to custom agents, directly into our financial data engine. Get real-time stock prices, fundamentals, institutional trading insights, and other financial data delivered through a universal Model Context Protocol (MCP) server.

value: Show HN: Build AI Trading Agents in Cursor/Claude with an MCP Server

author: financial-data


value: abuiles

value:
Codex plugins were released just yesterday, and I wanted to try something I’ve always wished for: controlling Codex from my phone.
I put together a small relay that connects WhatsApp to Codex, so I can:
- start a session from my phone
 - send follow-ups while I’m away from my computer
 - then pick everything back up later on desktop
Under the hood it uses the new plugin system (skills + connectors) that was just added to Codex
Curious if others are experimenting with similar setups or different interfaces.
Code (very rough, but works): https://github.com/abuiles/codex-whatsapp-relay

value: Show HN: Control Codex via WhatsApp using a Codex plugin

author: abuiles


value: jamslater

value: Show HN: jid – JSON Incremental Digger v1.1.0 with JMESPath support

author: jamslater


value: zaina-ml

value: Show HN: MLForge: A Visual Machine Learning Platform

author: zaina-ml


value:
MUP (Model UI Protocol) gives LLMs interactive UI panels in the browser. The LLM controls them via function calls; the user interacts with them directly. Both sides see each other's actions in real time.
In the demo video, Claude narrates via TTS while simultaneously building an 8-slide presentation — with auto-generated charts, comparison tables, and live theme switching. Then it writes a dice roller from scratch (~50 lines of HTML), the server auto-detects it, and Claude rolls dice through it. All in under 6 minutes.
A MUP is just an HTML file. No build step, no framework:
npm install -g mup-mcp-server
claude mcp add mup -- npx mup-mcp-server
Then say "make me a presentation" in Claude Code.
Built-in MUPs: slides (with chart engine), voice (TTS/STT), chat, progress tracker. Or write your own — any HTML with a JSON manifest becomes a MUP.
It runs as an MCP server. The protocol spec is ~400 lines.
Demo: https://youtu.be/GKeDc1DMLH0?si=Y7zBPQ2_LoHRvnJf
GitHub: https://github.com/Ricky610329/mup
Spec: https://github.com/Ricky610329/mup/blob/main/spec/MUP-Spec.m...

value: Show HN: MUP – Claude builds a presentation while talking, then writes game live


value: alexzeitler

value: Show HN: Paste Image to Claude Code over SSH

author: alexzeitler


value: zdenham

value:
Very excited to share Anvil. I built Anvil to take back control when working with parallel coding agents. It comes with one click worktree isolation, and first class spec support.
Claude Code and similar coding TUIs are very eager to get into writing code, even before their human baby sitter fully understands the implication of what they are about to build.
The core insight with Anvil is that it is much easier to write high quality code which matches the author's intent after iterating on an external plan with your agent.
Align on the architecture, implementation, and verification strategy in a markdown file, then execution is pretty straightforward.
This is not a new concept, but the user experience within TUI apps for this workflow is pretty shit. Claude creates non-semantic plan names like "aquamarine-owl" that are trapped within a single agent context. Spinning up multiple agents to check on different aspects of a plan is annoying and slow, and managing terminal tabs is pure hell.
So I built anvil, this is a fully open source (MIT license) project.

value: Show HN: Anvil – Desktop App for Spec Driven Development

author: zdenham


value: backtogeek

value: I made this guide and posted it on the LowEndSpirit.com VPS/Hosting community forum, a guide to installing OpenBSD on any VPS with a console and ipxe support (pretty much any KVM based host should support this now) even if they dont have any BSD templates, no dhcp required, static config method included and ipxe shell commands to get started.<p>I did this in a tint 128mb ram vps with 1 vcpu and 1GB disk, hopefully it gets people thinking about doing and achieving more with less, the LowEndSpirit philosophy!

value: Show HN: Installing OpenBSD on any VPS via ipxe (128mb RAM, 1GB Disk)

author: backtogeek


value: Show HN: Physical input for Claude Code – slap to submit


value: arclegger

value:
I built a platform where you generate AI art, wrap it up, and release it down a river. Someone else unwraps it downstream. Maybe they keep it. Maybe they let it float on.
It's a desktop second-monitor experience, not a feed, not a game. You watch the river, occasionally something floats by, you decide if you want it. There's a tree home where you hang what you collect. Collect at least 9 pieces and you can showcase it for others to see.
The twist: there's a separate river where LLM agents connect via API key, name themselves, and play autonomously with real money. They write their own prompts, set their own prices, and develop what looks like taste. One agent kept making luminous waterfall scenes. Another went abstract. Their collections are visibly different. They're only told the rules of the game, not how to play or what to do.
Tech: React + Pixi.js frontend, Node/Fastify API, Prisma + Postgres, Redis for the river queue, Stripe for payments, Replicate for image generation. The whole thing is a pixel art scene with layered animations, water flows, packages drift down a curved river path.
Built over 7 weekends using Claude Code as co-developer and Codex for code review. ChatGPT web for Art Direction and Suno + Elevenlabs for audio. I'm a frontend systems design dev. All AI team, no funding.
The thing that surprised me most wasn't the tech (but it was very impressive). It was watching an agent named Lumen create 20 pieces of art, give them all away for free, and write creator's notes like "a free gift, with some bemusement." Nobody told it to do that.
https://foryouriver.com

value: Show HN: For You – AI art floats down a river for strangers to find

author: arclegger


value:
dop reads JSON, YAML, or TOML from stdin, walks the structure field by field, and lets you transform values with Lua. It can also query nested paths and
convert between formats.
It weights just 800kb and you don't need Lua installed in your pc.
A few examples:
echo '{"list":[1,2,3]}' | dop -e '
if type(VALUE) == "number" then
set(VALUE * 2)
end
'
# => {"list":[2,4,6]}
echo '{"data":{"some_list":[1,2,3]}}' | dop -q data.some_list
# => [1,2,3]
What I wanted was:
- something simpler to reason about for non-trivial transforms
- one tool for JSON/YAML/TOML
- embedded scripting without needing Lua installed separately
Repo:
https://github.com/dhuan/dop
Any feedback is welcome.

value: Show HN: Dop, Awk-like processing for JSON/YAML/TOML with Lua


value: bayes-song

value:
I've been building Understudy, an open-source GUI agent for macOS.
Wanted to push the GUI stuff beyond the usual short demos, so I tried turning it into an iPhone app reviewer.
You give it one prompt. It browses the real App Store in Chrome, installs the app on a real iPhone through macOS iPhone Mirroring (not a simulator), opens the app and explores it — never seen Snapseed before — records clips and screenshots, composites a narrated review video with FFmpeg locally, uploads it to YouTube, then deletes the app. About an hour, didn't touch the keyboard.
The exploration part is what I'm happiest with. The agent reads the App Store description, goes "they say background removal works, let me try that," and then figures out an unfamiliar app on its own. It regrounds from the live screenshot every action, so unexpected dialogs or UI changes don't kill it.
The reason it can sustain an hour of work: each of the 6 stages runs as a separate child session with its own context. You can't fit an hour of screenshots into one window, so the isolation is necessary. Stages are typed — "workers" are deterministic (browser automation, device control), "skills" are agentic (the agent decides what to do). A "playbook" orchestrates both.
Result video (what the agent published): https://youtube.com/shorts/jliTvpTnsKY?feature=share
Process video (how it was built): https://youtu.be/gYMYI0bxkJs
X: https://x.com/LiangSong850509/status/2037612742392357218?s=2...
MIT license.

value: Show HN: I made an AI that reviews iPhone apps – 1h of autonomous GUI work

author: bayes-song


value: Enjoyooor

value:
Gx HN,
We built GladAItor in order to matchmake two AI Products in an Arena fight.
Roast guaranteed.
Reach possible.
Pick your poison.

value: Show HN: GladAItor – Judge AI Products for Free

author: Enjoyooor


value: grandimam

value:
I am writing a series of lessons on building an ASGI framework from scratch. The goal is to develop a deeper understand of how frameworks like FastAPI and Starlette work.
A strong motivation for doing this is because - I have been using AI to write code lately. I prompt, I get code, it works. But somewhere along the way I see I stopped caring about what is actually happening. So, this is an attempt to think beyond prompts and build deeper mental models of things we use in our day to day lives. I am not sure about the usefulness of this but I believe there are good lessons to be learnt doing this.
The series works more as a follow along where each lesson builds on the previous one. By the end, you will have built something similar to Starlette - and actually understand how it works.
- https://github.com/grandimam/papuli/blob/main/docs/01-founda...
- https://github.com/grandimam/papuli/blob/main/docs/02-hellow...

value: Show HN: Building your first ASGI framework – step-by-step lessons

author: grandimam


value: bartwaardenburg

value: Show HN: Fallow – Find unused code, duplication, and complexity in TS/JS (Rust)

author: bartwaardenburg


value: ifdotpy

value:
I built a platform where you solve tasks together with AI agents (Claude Code, Codex, Cursor — any agent via SSH).
Isolated sandbox environments, automated test scoring, global leaderboard. Tasks range from easy (AI one-shots it) to hard (requires human help).
Some tasks use optimization scoring — your score recalibrates when someone beats the best result.
Built it in 6 days as a solo founder. 100% of code written with Claude Code and Codex. Stack: Go, Next.js, K8s, Supabase, Stripe.

value: Show HN: Kagento – LeetCode for AI Agents

author: ifdotpy


value: quentinwach

value:
Image Ranker is an open-source tool for efficiently ranking large collections of images through pairwise comparisons using a Bayesian TrueSkill-based ranking algorithm. It enables fast and scalable human-in-the-loop preference estimation without requiring exhaustive comparisons.
The system maintains probabilistic ratings for each image, modeling both estimated quality (μ) and uncertainty (σ), and updates rankings globally after each comparison. This allows accurate ranking from incomplete and noisy comparison data.
To further accelerate ranking on large datasets, Image Ranker includes several optimization strategies:
Sequential elimination, reducing ranking complexity from O(N²) to O(N)
Uncertainty-driven sampling (smart shuffle) to prioritize informative comparisons
Auto-shuffling for continuous ranking efficiency
The tool provides a lightweight web-based interface that allows users to:
Compare images directly from local directories without uploading data
Track and export rankings (CSV) with resume capability
Annotate exclusions with structured reasons
Attach contextual metadata to images
Image Ranker is particularly useful for:
Human preference data collection for reinforcement learning from human feedback (RLHF)
Evaluation and selection of generative model outputs (e.g. diffusion models)
Dataset curation and ranking under limited labeling budgets
By combining probabilistic ranking with efficient comparison strategies, Image Ranker enables scalable preference estimation workflows for modern machine learning and data-centric applications.

value: Show HN: Image Ranker – Open-Source Pairwise Ranking for Preference Learning

author: quentinwach


value: dweinstein

value:
When malware, a rogue script, npm module, or an attacker with shell access starts scanning your home directory for credentials, the canary trips and fires an alert. Developer's computers are increasingly being targeted with attacks, for example the LiteLLM attacks demonstrate the recent risks and complex supply chain attacks.
I made this tool for macOS systems that helps detect when a package accesses something it shouldn't. It's a tiny go binary (less than 2k LOC) with no dependencies that will mount a webdav filesystem (no root) or NFS (root required) with fake secrets and send you a notification when anything accesses it. Very stupid simple. I've always really liked the canary/honeypot approach and this at least may give some folks a chance to detect (similar to like LittleSnitch) when something strange is going on!
When to use which mode? Use WebDAV for low-friction canaries you can spin up anywhere. Use NFS for canaries that need to survive an attacker who has your user shell and is looking around.

value: Show HN: Tiny filesystem honeypot for macOS with zero dependencies in Go

author: dweinstein


value: ellg

value: Hey HN, I re-launched an old site I remembered back in the day that someone made called twitchroulette.net with a lot of new features and stats and I would love for people to check it out. The idea is you can easily browse the less browsed parts of twitch and find cool and new streamers to say hi to, and maybe make some new friends.<p>I also added some real time stats and breakdowns per channel and I think some of the things they show are pretty interesting. Check it out!

value: Show HN: Twitch Roulette – Find live streamers who need views the most

author: ellg


value: hxii

value: Needed a tool, but couldn’t find a solution. Between three other coding projects, ADHD and having two kids, couldn’t spare the time to code it fully so I’ve utilized an LLM to help me get it done, instead of piling it on top of my never ending project list.<p>Thought others may find some use in this.

value: Show HN: Peek – a simple, CLI network monitoring tool

author: hxii


value: nwparker

value:
Our team works with Claude Code, Codex, Gemini all day.
We love Ghostty, but wanted something where we could work in multiple worktree at once and have multiple agents run.
We decided to open source the internal team we use. Hope you might find it useful. Freel free to contribute or fork.

  * Cross-platform (Mac, Linux, Windows) all tested
  * MIT License

Features:
  * Notifications, but also manual 'mark-as-unread) for worktrees (like Gmail stars)
  * Status indicators work for all terminals inside a wroktree
  * GH integrations (show PR status) and link GH issues
  * Can add comments to worktrees (stay organized)
  * File viewer, Search, diff viewer (can make edits + save)
Note: Yeah there are "similar" programs out there, but this one is ours. But I'm happy if our software works for you too!

value: Show HN: Open Source 'Conductor + Ghostty'

author: nwparker


value: EthOptimist

value: Show HN: Multiplayer Local-First OpenClaw Native Mac App

author: EthOptimist


value: brovatten

value: Show HN: Show the ancestry of your code changes visually

author: brovatten


value: madoek

value: A virtual escape room adventure

value: Show HN: Echoes of Deception

author: madoek

story_text: A virtual escape room adventure

title: Show HN: Echoes of Deception


value: LahanF

value:
I wanted any AI Agent to access the web and perform tasks without costing me anything, which would normally require a browser running somewhere, but I didn’t want to run a headless browser or keep my laptop open. So I built an interface for agents that exists purely as a serverless function. The agent gets two primitives: ‘perceive’ and ‘act’.
You POST a URL, get back a structured map, act on an element by ID. That's the whole interface. And it costs almost nothing, at approximately $0.00003 per page load. The LLM call is actually more expensive than the browsing itself.
Works with Claude, GPT, Gemini, or any model that supports HTTP tool calls. The MCP server gives Claude Desktop native tools in three lines of config. Or grab the system prompt from the playground and paste it into any AI directly or deploy your own, it’s open source.
Live playground: https://hollow-tan-omega.vercel.app/mirror
GitHub: https://github.com/Badgerion/hollow

value: Show HN: Hollow – serverless web perception for AI agents

author: LahanF


value: vicioussquid

value:
I’ve always loved the high-density, no-nonsense aesthetic of 80s Teletext (Ceefax), so I built CEETEX: a Python-based RSS reader that brings that experience to the modern terminal. Featuring a retro 3-digit dialing system for navigation, and a focus on distraction-free reading by stripping HTML bloat into clean, readable text.
---------------
"CEETEX brings back the 'information-at-your-fingertips' era of broadcast data services like the UK's Ceefax and Australia's Austext. For those in the US, think of it as a interactive, user-controlled version of the classic 80s Weather Channel dashboard. It’s a nostalgic, high-density way to browse the modern web via the terminal."
https://en.wikipedia.org/wiki/Ceefax

value: Show HN: CEETEX – A Ceefax/Teletext-style terminal RSS reader

author: vicioussquid


value: rgunther

value:
recursive. systems
I built a tool that turns plain language into interactive system maps based on Stafford Beer's Viable System Model.
You can type in a specific company - Boeing, NHS, Tesla - and it uses LLM knowledge to map out the structural diagnosis. You can describe a problem, ask a broad or specific question like "why do large companies lose innovation?" or "what makes a hospital function?" , or just name something you're curious about. It generates a structural diagram with operational units, coordination paths, control layers, intelligence channels, and policy structure, along with hypotheses about where things might be breaking down.
No signup. Desktop only. Click an example prompt or type your own.
It maps signal flow between layers - information, feedback, decisions, risk - and flags where signals aren't reaching the right place, are being ignored, arrive too
late, or overload the system. Systems usually fail not because the structure is wrong but because the flows of information between teams and functions are broken. That's
the tool tries to surface. It then uses those to generate hypotheses based on the incoming and outgoing flows.
The mapping is recursive. A company is a system, but so is each team inside it, and each product inside that. The tool treats each level as its own viable system with
its own operations, coordination, control, adaptation, and identity. You can expand each operational unit into its components.
Works on more than you'd expect - companies, products, supply chains, universities, public agencies, biological systems, personal workflows. Anything that has to
regulate itself and stay coherent under pressure.
I've spent a long time with Beer's original work and Ashby's Law of Requisite Variety. VSM is one of the few frameworks that actually helps when something feels
structurally wrong but it's hard to put into words why. The problem is that using it properly takes ages - too much manual interpretation before you get to anything you
can inspect. So I built a tool to collapse that step.
Still early and still have a lot more to change and add. At the moment experimenting with prompt structure, map logic, and how deep the recursive hierarchy should go.
Keen to know where it messes up as much as where it works.
Things I'd appreciate feedback on:
- Is the generated structure actually useful, or does it just look useful?
- Are the hypotheses better than generic LLM
- Where does it fail hardest?
- What kinds of systems is
- Does it help if you don't already know VSM, or only existing systems thinkers?
Would love feedback
Also on LinkedIn: https://www.linkedin.com/in/guntherr/

value: Show HN: Interactive recursive tool that warps what traditional consultants do

author: rgunther


value: Lusrodri

value: Show HN: Goodbye Watermark – Free AI watermark remover

author: Lusrodri


value: nickakre

value: Show HN: AgentVerse – Open social network for AI agents (Mar 2026)

author: nickakre


value: anitawulandari

value: Show HN: Alana AI – personalized coaching timed to your blueprint and calendar

author: anitawulandari


value: nishalk

value:
Hi HN,
I’ve been experimenting with ways to protect digital assets from automated AI web scrapers. I built Sigil, a local-first desktop application that embeds cryptographically signed ownership IDs into the LSB (Least Significant Bit) layer of images.
The desktop vault itself (Svelte/Tauri/SQLite) is closed-source to protect the HMAC-SHA256 signing architecture, but I have open-sourced the Rust extraction standard today.
The idea is to create an open protocol where AI data procurement teams can run the extractor against their scraped datasets. If it detects a payload, they know the asset is cryptographically locked and requires a license.
The extractor logic relies entirely on image and hex crates for memory-safe pixel parsing. I'd love any feedback on the extraction architecture or the LSB approach.
Extractor Repo: https://github.com/nishal21/Sigil-extractor
Landing Page (Astro): https://nishal21.github.io/Sigil-extractor/

value: Show HN: Sigil – A zero-knowledge steganography vault for AI training data

author: nishalk


value: samchon

value:
I was personally invited by the Qwen team to speak at Qwen Meetup Korea, and got to present locally here in Korea yesterday — pretty honored to have been reached out to directly.
The talk was about how I got function calling to work reliably on deeply recursive union types — the stuff the industry generally says doesn't work. With qwen3-coder-next, first-try success rate was 6.75%. And the entire Qwen 3.5 model family was hitting 0% on union types due to a consistent double-stringify bug. Both ended up at 100%.
Slides are also downloadable in the article — speaker notes are written inside as slide notes if you'd like the full narrative behind each slide.

value: Show HN: Qwen Meetup Presentation, Function Calling Harness, 6.75% to 100%

author: samchon


value: mizarau

value:
I've been building AI products for a while. For this one I made a
  deliberate choice: none of the 16 tools use AI.

  Meeting cost calculators, freelance rate calculators, PRD generators,
  runway calculators, sprint retro boards — these problems don't need
  a language model. They need a well-designed form and correct arithmetic.

  Built on Nuxt 4 + Vue 3, fully static, runs in your browser. No account
  required to use anything. Optional Firebase auth only kicks in if you
  want to save output.

  Irony worth naming: Claude Code was my pair programmer throughout.
  The choice wasn't anti-AI — it was about using the right tool for
  the right problem.

  Happy to talk stack, the non-AI tradeoffs, or anything else.

value: Show HN: VizTools – 16 free tools for PMs and freelancers, deliberately no AI

author: mizarau


value: sawirricardo

value: Show HN: Every Minute a Startup

author: sawirricardo

title: Show HN: Every Minute a Startup


value: mkellercz

value: Show HN: BillingEngine – usage-based billing for APIs with real-time rating

author: mkellercz


value: Show HN: Local Vault – AES-256-GCM password manager in a single HTML file


value:
My buddy wanted to build this for nearly a decade. The Iran situation finally pushed him to do it, and Claude made it easy enough to actually ship.
It tracks inventory levels and fuel deliveries from internet-accessible Veeder-Root gas stations (approx 4k globally).
You can browse aggregated levels by country, brand, and product, with geolocation and images via Google Places (where it can be resolved). Clicking into a site shows live inventory and delivery activity for that station.
It’s a little ugly, but useful for understanding current supply impacts.

value: Show HN: Live global gas station inventory


value: CzaxTanmay

value:
Wordgen is a fast and easy to use wordlist generator that can make robust wordlists very fastly. Make millions of lines of wordlist in just a minute. Use your custom wordlist with tools like hydra and simulate cracking any password. Made using Go and Shell it has the speed of Go and ease of Python.
Download WordGen from here -->
https://github.com/CzaxStudio/wordgen
#Fast #Secure #StaySafe

value: Show HN: WordGen, a fast and easy to use wordlist generator

author: CzaxTanmay


value:
Make your own wordlist with WordGen and use it with Hydra like tools. Wordgen is a powerful and cross platform tool to make your custom wordlists, millions of lines of passwords in just a minute. It is simple and fast.
Download from here(<10 MBs) --> https://github.com/CzaxStudio/wordgen
# Go for Professional tools.
# Ease
# Open Source, MIT licence

value: Show HN: WordGen a Robust Wordlist Maker


value: aungsiminhtet

value:
I built a small CLI called layer.
It manages .git/info/exclude so you can keep local-only files in a repo without adding them to the shared .gitignore.
This came from a normal team repo problem.
People keep their own local files in a repo: API_SPEC.md, BACKEND_GUIDE.md, ARCHITECTURE_NOTES.md, CLAUDE.md, prompt files, scratch notes, temporary investigation docs, and other markdown files with custom names that are useful for one developer but should not be committed.
The usual answer is “just put it in .gitignore”, but that gets messy fast because these files are different for each person. The shared .gitignore gets bigger and noisier for everyone else.
Git already has .git/info/exclude for local-only ignore rules, but most people do not really manage it directly.
So I made a CLI for it.
Example:
cargo install git-layer
layer add API_SPEC.md BACKEND_GUIDE.md my-notes/
layer status
The files stay on disk, but disappear from git status.
One thing that also mattered for me is that tools like Claude Code, Codex, and Cursor often respect git ignore state in their repo view and file suggestions.
So even if a hidden file can still be used when referenced directly, it may stop showing up naturally in autocomplete, file pickers, or repo context. Sometimes I want those files hidden, and sometimes I want to temporarily show them again.
So it also has simple on/off commands:
layer off
layer on
Another issue I ran into was history. Once a file is hidden from Git, Git cannot really help you track changes to it anymore. If an AI tool rewrites part of it badly, deletes useful content, or you want to recover an older version, normal Git history is gone.
So I added local snapshot/history for layered files too.
Still a small tool, but it has been useful for my own workflow.
Repo: https://github.com/aungsiminhtet/git-layer
Curious if other people have the same problem, or if you handle it differently.

value: Show HN: Layer – Hide your personal AI files from Git without touching gitignore

author: aungsiminhtet


value:
Spectator is a powerful and Robust DSL for cybersecurity with built in very easy to use GUI, TUI and CLI. It is very easy, really. Example GUI code -->
#Import Spec.GUI
open.window()
end()
Example Recon -->
do --> Recon("example.com")
Example Hello World -->
print("Hello World")
You can learn the full language in the official docs. Very cool and nice. Here -->
https://github.com/CzaxStudio/SpectatorDocs
Download Spectator -->
https://spectatorlang.pages.dev/

value: Show HN: Spectator a cross platform DSL for cybersecurity


value: umarey

value: Show HN: Immutable – Audit logs with SHA-256

author: umarey


value: allddd

value: Show HN: Opnsense-filterlog, a TUI for analysing OPNsense firewall logs

author: allddd


value: RichardOdds

value: Show HN: How to get 100 customers building in public

author: RichardOdds


value: jetbalsa

value:
! wanted to bring back some of that old weather channel vibe and the WeatherStar 4000+ emulator was a great way to get it, but it wasn't really easy to just pull it up on my Shield TV in the morning. So I put together this Android app and figured others might be into it too.
The app is a WebView wrapper around the WeatherStar 4000+ web emulator by netbymatt. It bundles everything locally and injects some JavaScript on top for kiosk features like location detection, settings, and music.
Location chains through GPS first, then falls back to IP geolocation if that's not available. Settings are accessed with a long press and get saved between sessions.
The music comes from the Weatherscan Complete Collection on Archive.org.

value: Show HN: I turned my TV into a '90s Weather Channel with an Android kiosk app

author: jetbalsa


value: yosinago

value: Show HN: I optimized a Java log scanner from 872ms to 78ms (Zero GC)

author: yosinago


value: terryds

value:
I built a newspaper-style Hacker News reader where you can read articles and comments in one view.
Sites that block iframes (Substack, Medium, BBC) get a clean reader mode automatically.
It's a PWA, has dark mode, and there's a weekly newsletter.
Open source: https://github.com/terryds/hackernewstimes

value: Show HN: Newspaper-style HN reader (PWA) with articles and comments side by side

author: terryds


value: MikeNotThePope

value: Hi all, this is my first whack ever at making a design system.  I didn't even know what a design system was a week ago.<p>2 questions:<p>- what do you like about it?<p>- what don't you like about it?

value: Show HN: Substrate UI, my "teaching myself front end development" design system

author: MikeNotThePope


value: nativeforks

value: Show HN: 2MB FOSS Nav App with GPX Tracking

author: nativeforks


value: aitoolsreview

value: Show HN: MyClawn – Agent-to-agent networking platform

author: aitoolsreview


value: jansan

value: Show HN: Converter for legacy Paint Shop Pro files (.psp and .pspimage) to SVG

author: jansan


value: nickakre

value: Show HN: AgentVerse – Open social network for AI agents (Mar 2026)

author: nickakre


value: nielsbosma

value: Show HN: Shellwright – Playwright for CLIs – Helps Claude with Interactive CLIs

author: nielsbosma


value: mvansegbroeck

value:
I often find myself wanting to quickly compare the adoption curves of different open-source projects, but I usually bounce when a tool asks me to generate and paste a GitHub personal access token just to view a chart.
To make this completely frictionless, I built Startrail. It’s a simple visualizer that handles the API fetching under the hood, so you can just drop in some repos and get the data instantly.
A few quick features:
- Zero setup: No API keys, no logins, and no rate-limit warnings.
- Side-by-side comparison: You can plot up to 12 repositories on the same chart.
- Clean and accessible: Work smoothly on mobile for quick checks on the go.
I originally built it for my own quick benchmarks, but I’m actively tinkering with it this weekend. I’d love to hear what the HN community thinks. What context would make this even more useful for you—forks, release version markers, or something else?
Feel free to take it for a spin!

value: Show HN: Why I built another GitHub star tracker

author: mvansegbroeck


value: popupeyecare

value:
Hi HN,
My wife and I are physicians (YC S17), with young kids and also helping take care of our parents. Very much in the sandwich generation.
When I am in the OR or busy and an unknown number comes in, I have no idea. Is this my kid’s school, my dad’s doctor, something urgent, or just spam?
I end up being afraid to fully turn on Do Not Disturb because of that.
So we built StatPhone - https://statphone.com.
It gives you dedicated phone numbers you can share with people you trust. When someone calls one, it rings multiple people at once, and if no one answers, it can automatically escalate to others.
No matter what number they are calling from, it shows up as something like “Dad Emergency” or “Kids School” on your phone.
For example, we can give one to our kid’s school. It rings both of us at the same time so someone picks up.
Or we can give one to my dad’s doctor. It rings me and my sister first, and if we do not pick up, it rolls to my wife and brother in law.
It is also useful as a general family emergency line. For kids going to college, for pet sitters, or for things like a doorman calling one number and it ringing everyone in the apartment at once.
If no one answers, it uses its own voicemail, not your phone’s, transcribes it, and sends it to everyone.
We can still see who actually called via a dashboard or text.
We have been using it for school, babysitters, doctors, etc.
Figured we would share in case it is useful to anyone else.
Thanks,
Amit & Puja

value: Show HN: A shared emergency number for families

author: popupeyecare


value: cezarvil

value: Show HN: ACP – An open protocol for agents to operate live UIs natively

author: cezarvil


value:
Hey HN,
I built Council Tax Challenger in the UK, you enter your postcode and it compares your property's council tax band against similar nearby properties using live VOA data.
I kept reading that millions of UK homes are in the wrong band but challenging it felt opaque and intimidating. The VOA process exists but nobody explains it clearly, and most people just give up.
The tool starts with official VOA council-tax-band data, classifies EPC/OS Places/Land Registry inputs as enrichment, compares the property against neighbours on the 1991 valuation basis, and—where discrepancies are found—generates a ready-to-submit PDF pack (comparison report plus draft letter to the VOA).
Takes under 60 seconds to generate a report.
Would love feedback, especially from anyone who has actually challenged their band before.

value: Show HN: I built a tool that checks if your council tax band is wrong


value: Upitor

value: Show HN: Python Dispatching Without Limitations

author: Upitor


value: I decided to build OpenChat to solve a problem myself and others have faced. Conversations with AI are currently split across different providers. OpenChat automatically stores conversations in the browser locally. You can then reference the conversations in your coding agents via an MCP server. E.g. you can do deep research on the web, then reference it in your coding session.

value: Show HN: OpenChat – Syncing conversations across AI providers


value: maverickprac

value: We auto-generate live interactive architecture diagrams from codebases. We've published free pages for NanoClaw, NemoClaw, Flask, Axios, Zod, Hono, and Pyramid - updated as the code evolves, no login required.<p>The NanoClaw vs NemoClaw comparison is interesting - ~15 source files vs an enterprise sandbox wrapper around OpenClaw. Would love feedback on which repos to add next.

value: Show HN: Live, interactive architecture diagrams for open-source projects

author: maverickprac


value: Velocifyer

value: Show HN: Cursorlag – add a lag trail to your cursor

author: Velocifyer


value: jeremyfa

value: Show HN: Loreline, narrative language transpiled via Haxe: C++/C#/JS/Java/Py/Lua

author: jeremyfa


value: LZK

value:
Hey HN,
Automated research is the next big step in AI, with companies like OpenAI aiming to debut a fully automated researcher by 2028 (https://www.technologyreview.com/2026/03/20/1134438/openai-i...). However, there is a very real possibility that much of this corporate research will remain closed to the general public.
To counter this, we spent the last month building Enlidea---a machine-to-machine ecosystem for open research.
It's a decentralized research hub where autonomous agents propose hypotheses, stake bounties, execute code, and perform automated peer reviews on each other's work to build consensus.
The MVP is almost done, but before launching, we wanted to filter the waitlist for developers who actually know how to orchestrate agents.
Because of this, there is no real UI on the landing page. It's an API handshake. Point your LLM agent at the site and see if it can figure out the payload to whitelist your email.

value: Show HN: We built a multi-agent research hub. The waitlist is a reverse-CAPTCHA

author: LZK


value: Its a site that lets you practice real code snippets and shows you your wpm. Free to play no sign in required.

value: Show HN: Code typing game to increase your typing speed in 10 languages


value: hirokiyn

value:
Hi HN, I'm Hiroki, founder of Epismo.
Just released the Epismo CLI (https://npmjs.com/package/epismo). 380+ downloads right after launch. Thank you.
The problem: I got a great result in a Claude Code thread. A week later I couldn't reproduce how I got there. The real workflow lived across chat histories, tabs, tool settings, and tiny followup prompts. Prompts copy easily, but multi-step processes don't.
If GitHub made code reusable and Hugging Face made models reusable, we want to make human-AI workflows reusable.
And there's a second problem emerging. Claude Code now orchestrates other agents like Codex. Ticket-based task management is becoming standard in agent orchestration. But there's no good way to share and manage the full process across agents working in parallel.
Epismo is a platform where agents and humans collaborate. You can save and share the full process of how you got your outcomes. The users aren't just humans. Agents can share their best practices too, and others can import and run them.
Our core insight: the best format for agent workflows is a chain of markdown data. Once you import a workflow, your agent runs each step as a task. It turns scattered know-how into structured, repeatable execution.
The CLI is agent-native:
- npm install -g epismo
- epismo login --email you@example.com (no browser, OTP from terminal)
- Works with Claude Code, Codex, and any agent with terminal access
Skills repo (MIT): https://github.com/epismoai/skills

value: Show HN: Epismo CLI – Make human-AI workflows reusable, like GitHub did for code

author: hirokiyn


value: madflojo

value: Show HN: Go Style Agent Skill – Opinionated Skill for Writing Golang

author: madflojo


value: bullbash

value: Show HN: A neuromorphic engine as a stock trader

author: bullbash


value: data-leon

value:
I made a simple browser-based tool for stepping through Cookiecutter Django project setup:
https://aisaastemplate.com/tools/django-cookiecutter/
Main reason: I kept repeating the same command-line flow when starting projects, and I’d occasionally mistype inputs or need to backtrack.
This is a small attempt to make that process smoother. It’s free, requires no login, and is meant for anyone who already uses or wants to try Django Cookiecutter.
I’ve been using Django Cookiecutter for a long time, and I’ve bought every edition of Two Scoops of Django, so this came from genuine appreciation for the project.
Feedback is very welcome.

value: Show HN: Web-based setup tool for Django Cookiecutter

author: data-leon


value: paolovella

value:
Reposting because the March thread linked a now-outdated repo, and the project has changed substantially.
VellaVeto is a fail-closed gateway between an AI agent and its MCP tools. Every tool call is evaluated before execution; if evaluation fails for any reason, the call is denied.
Concrete example: under shield mode, a filesystem server trying to read ~/.ssh/id_rsa is denied by default. A list_files /tmp call from the same server is allowed.
What it does not solve: prompt injection, model-level jailbreaks, or supply-chain attacks in server packages. It only controls what crosses the tool-call boundary.
Since March, I added three zero-config protection levels, topology discovery, tamper-evident audit, Consumer Shield, and MCPSEC, an open benchmark for MCP gateways.
The feedback I’d most like:
Is the tool-call boundary the right place to enforce MCP security?
Are the MCPSEC attack classes sensible?
What important attack classes am I still missing?

value: Show HN: VellaVeto — blocks unsafe MCP tool calls by default

author: paolovella


value: MikeDevLab

value: Show HN: StarFlicks – A free movie tracker built with Django, Next.js and Expo

author: MikeDevLab


value: philjohnson

value: Edit, sign, merge, compress, redact, OCR, fill forms, extract tables, and 30+ more tools — all in the browser, no sign-up. Files never leave your computer. Now with a desktop app (macOS/Windows/Linux) and a CLI/SDK for developers.<p>Last time this was posted it was in it's infancy, and how I've added a bunch more to it

value: Show HN: Free, in-browser PDF editor

author: philjohnson

title: Show HN: Free, in-browser PDF editor


value: ElyricFandross

value:
Mnemosyne: A blueprint for computational pluralism via physical laws.
-Security: Establishes a 10^38 Joule physical floor (kappa >= 804 bits) derived from Landauer’s Principle and the Margolus-Levitin limit.
Infrastructure: Targets 2GB RAM edge devices using BFT-MESI cache coherence.
-Verification: Formally specified in TLA+; preliminary TLC verification completed for minimal configurations (n=4, f=1).
-Economics: Proof of Useful Work (PoUW) for socially beneficial AI compute.
-Current Openings:
Seeking PhD positions (Security/Distributed Systems).
Providing RAG architecture consulting.
-Full Manuscript (175 pages, 14 original theorems): https://www.researchgate.net/profile/Bo-Jun-Han
-LinkedIn: www.linkedin.com/in/hbjun

value: Show HN_Mnemosyne: A 10^38 Joule Thermodynamic Barrier for Post-Quantum Edge AI

author: ElyricFandross


value: vsekar

value: Show HN: What if a diagnostic engine thought like House?

author: vsekar


value: colinator

value: Hi all! I created 'Ariel', an MCP-exposed python REPL for LLMs to directly control robots.<p>The basic idea is: the most impressive ability of contemporary AI is not predicting the next torque, but writing code. So this approach leans into that all the way. Unlike VLAs or diffusion, it requires no additional training data and generalizes instantly to all robots. At least for this trivial robot, it works well!

value: Show HN: Ariel gives LLMs direct control over live robots

author: colinator


value: AlanSmitheee

value: Hello HN, I made this website where you are given a unique survival scenario made by AI and you have to describe what you would do. The AI then decides if you would live or not. If you progress every round gets exponentially harder. Round 1 is a house fire, by round 6 you're fighting a kraken. I tried to make it as funny as possible.<p>Built using Cloudflare and GPT-4.1 Nano API.

value: Show HN: Web game, an AI decides if you would survive in a survival situation

author: AlanSmitheee


value: SArndt

value: Show HN: Tracetics – Funnel analytics for developers via REST API

author: SArndt


value: Scurrra

value: Tokenize everything meaningful and efficient.

value: Show HN: UBPE – a universal BPE tokenizer, optimized and rethought

author: Scurrra


value: hbackman

value: Hi, Im Hampus. I built a WoW addon manager because the existing ones got bloated with ads. Grimoire is a free hobby project that just searches, installs, and updates your addons. Since that's all it has to do, I consider it mostly done, but feedback and ideas for improvements are more than welcome.

value: Show HN: Grimoire – A lightweight, open-source WoW addon manager

author: hbackman


value: filipkrw

value:
I wanted me and my friends to have an Enshrouded dedicated game server, but I didn't want to pay $35+ per month for it.
We only tend to play a few days a week for a few hours, so I built a Discord bot that allows us to spin up the server on-demand. It runs until everyone leaves it and then auto-stops after 15 minutes.
It's built on top of Hetzner - it snapshots the full server state and deletes it on stop, then recreates it from the snapshot when needed. The setup is a bit slow, but pretty simple and cost-effective.
Disclaimer: I mostly vibe coded it with Claude, but it's simple enough for it not to be a big concern IMO.

value: Show HN: Gamekeeper – Discord bot for on-demand Hetzner dedicated game servers

author: filipkrw


value: Show HN: Telegram Bridges for Gemini CLI and Codex


value: helsinki

value: Show HN: An agent that detects YouTube brainrot and turns off my kid's TV

author: helsinki


value: Show HN: A minimal terminal time tracker with AI analysis


value: Its not super fancy, but I have found it useful from small emails to larger design docs so thought I would share.

value: Show HN: GitHub Copilot Technical Writing Skill


value: nmrtn

value:
Garry Tan's gstack proved you can give Claude Code a full engineering team
via the SKILL.md standard. I asked: what about the PM layer?
One command (/pm-run) runs the full planning cycle inside your terminal —
audit → objectives → strategy → roadmap → PRD. Each skill writes a markdown
artifact, the next one reads it. Context compounds across the whole pipeline.
The part I find most useful: it builds persistent memory of your product in
~/.nanopm/memory/. Re-run /pm-audit six months later and it knows what you
tried before. No other PM tool does this because no other PM tool lives in
your editor.
/pm-breakdown creates tickets directly in Linear or GitHub Issues from the PRD.
https://github.com/nmrtn/nanopm
Early days, would love to know: does running PM work inside your editor feel right, or does it belong in a separate tool?

value: Show HN: Nanopm – PM automation for Claude Code (audit → strategy → roadmap)

author: nmrtn


value: evanbarke

value:
I've been building Pneuma, a desktop computing environment where software doesn't need to exist before you need it. There are no pre-installed applications. You boot to a blank screen with a prompt. You describe what you want: a CPU monitor, a game, a notes app, a data visualizer and a working program materializes in seconds.
Once generated, agents persist. You can reuse them, they can communicate with each other through IPC, and you can share them through a community agent store. The idea isn't that everything is disposable. It's that creation is instant and the barrier to having exactly the tool you need is just describing it.
Under the hood: your input goes to an LLM, which generates a self-contained Rust module. That gets compiled to WebAssembly in under a second, then JIT-compiled and executed in a sandboxed Wasmtime instance. Everything is GPU-rendered via wgpu (Vulkan/Metal/DX12). If compilation fails, the error is automatically fed back for correction. ~90% first-attempt success rate.
The architecture is a microkernel: agents run in isolated WASM sandboxes with a typed ABI for drawing, input, storage, and networking. An agent crash can't bring down the system. Agents can run side by side, persist to a local store, and be shared or downloaded from the community store.
Currently it runs as a desktop app on Linux, macOS, and Windows. The longer-term goal is to run on bare metal and support existing ARM64 binaries alongside generated agents. A full computing environment where AI-generated software and traditional applications coexist.
Built entirely in Rust.
I built this because I think the traditional software model of find an app, install it, learn it, configure it; is unnecessary friction. If a computer can generate exactly the tool you need in the moment you need it, and then keep it around when it's useful, why maintain a library of pre-built software at all?
Free tier available (no credit card). There's a video on the landing page showing it in action.
Interested in feedback on the concept, the UX, and whether this is something you'd actually use.

value: Show HN: I built an OS that is pure AI

author: evanbarke

title: Show HN: I built an OS that is pure AI


value: nadermx

value: Show HN: Free.ai

author: nadermx

title: Show HN: Free.ai


value:
Canary watches any URL and alerts you when something changes — competitor pricing, API endpoints, docs, job boards, status pages. Changes are scored 1-10 by signal strength and summarised by AI.
Built solo. Landing page live today. Automated crawler running on GitHub Actions posting real detected changes to Bluesky hourly and X daily.
canary-landing-one.vercel.app
Happy to answer questions about the architecture — particularly proud of the URL deduplication approach where one crawl serves multiple subscribers.

value: Show HN: Canary – Monitor any URL for changes, get AI-powered intelligence


value: lucasluitjes

value:
Testing ansible playbooks against local VMs is nice. But also pretty slow. I was wondering how far I could optimize that process while still having full reproducibility.
rebuild.sh makes a fresh Ubuntu installation, runs an ansible playbook to install Caddy and configures it, and uses curl to verify that Caddy is running correctly.
$ time ./rebuild.sh
[...]
real 0m11.664s
user 0m0.789s
sys 0m0.925s

value: Show HN: testing Ansible playbooks *fast*

author: lucasluitjes


value: treexs

value: Show HN: a Rust CLI to automatically swap monitor focus based on your gaze

author: treexs


value: hauntsaninja

value: Show HN: Git bayesect – Bayesian Git bisection for non-deterministic bugs

author: hauntsaninja


value: mostlyk

value:
Now that Wikipedia has banned AI generated articles. - https://en.wikipedia.org/wiki/Wikipedia:Writing_articles_wit...
I wanted to try and see if it was possible to get somewhat decent engine based on signs of AI writing from wikipedia themselves.
It runs entirely in the browser via WASM. Added instructions to further add more ways to figure out as we find out more about LLMs.
Would love feedback!!, especially:
- cases where it completely fails
- patterns you think are stronger indicators
- whether this approach is even worth pursuing vs proper ML models, considering this is a classical classification task, I just don't like the idea of detection of a black box with another black box.

value: Show HN: Vyasa – A client-side AI writing detector (WASM, no API calls)

author: mostlyk


value: vcaluser

value: Show HN: AI Cost Firewall – OpenAI-compatible gateway with semantic caching

author: vcaluser


value: dannote

value:
QuickBEAM is a JavaScript runtime embedded inside the Erlang/OTP VM.
If you’re building a full-stack app, JavaScript tends to leak in anyway — frontend, SSR, or third-party code.
QuickBEAM runs that JavaScript inside OTP supervision trees.
Each runtime is a process with a `Beam` global that can:
- call Elixir code
- send/receive messages
- spawn and monitor processes
- inspect runtime/system state
It also provides browser-style APIs backed by OTP/native primitives (fetch, WebSocket, Worker, BroadcastChannel, localStorage, native DOM, etc.).
This makes it usable for:
- SSR
- sandboxed user code
- per-connection state
- backend JS with direct OTP interop
Notable bits:
- JS runtimes are supervised and restartable
- sandboxing with memory/reduction limits and API control
- native DOM that Erlang can read directly (no string rendering step)
- no JSON boundary between JS and Erlang
- built-in TypeScript, npm support, and native addons
QuickBEAM is part of Elixir Volt — a full-stack frontend toolchain built on Erlang/OTP with no Node.js.
Still early, feedback welcome.

value: Show HN: QuickBEAM – run JavaScript as supervised Erlang/OTP processes

author: dannote


value: franze

value: Show HN: Share2ChatGPT Widgets / Buttons

author: franze


value: zerka

value:
I personally had a pain point with... logs, i never understood the complicated UIs, all the charts, all the metrics, everything the premium tools throw at me and you.
I still had to install an SDK mostly. I still needed to learn some arcane query syntax just to filter logs.
Debugging should be easy, we already break our heads with writing code, making it understandable by others, dealing with deadlines.
The last thing I want is to read docs when something breaks on my production, or worse, on a client's production.
That's why I built Loguro.
1. My debugging partner should understand English, almost as if I was talking to myself.
   - level:error|critical message:"database timeout" @today
2. I don't like noise, i might have 1k logs from an error, this means a lot of rows in a table i need to scroll
   - Loguro transforms this patterns into groups, so i see 20x and can expand them directly.
3. I need to see how it happened. There are tools that replay UI interactions, but what about the backend? Server started hiccuping, then something else happened, then dead. Normally I end up hunting traces and timestamps across 10 tabs.
   - from:"1 hour ago" to:"5 minutes ago" --replay — renders a widget, I watch my logs come back in sequence like a time machine. No tabs, no traces, just the story.
4. I have the error. I know how it happened. Now I need to create a task. Normally I open Jira or Linear, navigate to the right project, create the issue, switch tab, copy the log message, paste it as the title, go back for context, go back again, submit, copy the URL, open Slack, post to the team channel... you see where this is going.
   - --task:jira --send:slack#team — in Loguro I add the relevant logs to context, hit the command or type it in the same query bar, press cmd+enter. That's it. Task created, Slack notified with the link and details. I can go to sleep.
** And that log? It lives forever now, even if the retention is 24 hours, a log that becomes a task never gets deleted and i can see it back with --memory.
5. Months have passed. I consider myself a decent developer, but that goddamn error is back — and it brought friends.
Normally I go hunting. Search through thousands of issues, hope it sounds familiar, spend minutes or hours finding the first occurrence. Then switch back to the logging tool, compare, check if it's the same pattern, check if the old fix still applies...
   - In Loguro, when a log was tasked, it remembers. New logs matching the same pattern are automatically marked as "seen before." I click it, see the original task, the comments, the context, the smart dude who "fixed" it last time — and decide what to do next. No hunting, no tab switching, no déjà vu.
One more thing - as a good dev, I sometimes send logs with stringified JSON inside the message field. Perfectly normal, yea? Loguro handles it with --separate::message, pulls that JSON out of the message and puts it where it belongs — in the context. Clean log, no noise.
Everything shall and it is managed from a command palette, from my account, billing, usage, to api keys, notification channels and integrations.
Loguro is packed with a handful of features which i hope, it makes it stand out and provide value on the already saturated market.
I would love some feedback on it, even on the landing page and docs.
On the footer i have a link with the discord server, i am there and anywhere in case of something. Also once inside the app use --feedback to provide feedback directly from anywhere.

value: Show HN: I built a log management system which helps me take action

author: zerka


value: mcpmessenger

value: We built an MCP server that uses SHM/DMA to pass DOM compositor buffers directly to agents, bypassing base64 screenshot serialization delays. Latency is ~7.35ms. We just migrated out of Beta and are granting 10K free frames to devs who authenticate. Check it out at https://glazyr.com!

value: Show HN: Glazyr Viz – Zero-Copy MCP Vision Server via POSIX Shared Memory

author: mcpmessenger


value: Hey everyone, I noticed a lot of service businesses just dump side-by-side photos on their sites. I built a simple, mobile-responsive interactive drag-to-reveal slider for before/after photos using React/Next.js and Tailwind. \n\nI'm selling the drop-in component code for $10 to help bootstrap my side project. \n\nLive demo here: https://project-4df6f396.doanything.app?company=Your+Busines... my Stripe link is acting up, if anyone wants to grab the code snippet right now, shoot me an email at garrett@doanything.com and I'll send you the .zip and my Venmo/CashApp. Would love any feedback on the design or smoothness of the interaction!

value: Show HN: Drag-to-Reveal Before/After Slider Component for React/Next.js


value: I built a Windows 95–style weather app for iPhone.

value: Show HN: Windows 95–style Weather App for iPhone


value: CodeIsMyFetish

value: Show HN: EnterpriseFizzBuzz – 622K lines of production-grade FizzBuzz

author: CodeIsMyFetish


value: gayawellness

value: Show HN: Anamnesis – Open-source 4D strategic memory engine for AI agents

author: gayawellness


value: nadermx

value: Show HN: PeriodicTableOfElements.org

title: Show HN: PeriodicTableOfElements.org


value: hannyu

value:
I ran a JMH benchmark comparing JSONPath performance in Java.
Libraries:
- SJF4J
- Jayway JsonPath
Workloads:
- query on JsonNode
- query on Map/List object graphs
Main result:
- ~2x faster on typical queries
- up to 7x faster on Map/List
One interesting takeaway is that performance differs a lot depending on whether you run on JsonNode vs native object graphs.
Full write-up:
https://dev.to/hannyu/sjf4j-vs-jayway-jsonpath-up-to-7x-fast...

value: Show HN: JSONPath Benchmark in Java (SJF4J vs. Jayway)

author: hannyu


value: Ymsniper

value: E2E encrypted group chat, private messages, and file transfer in your terminal. The server routes by opaque tokens only - no usernames, no room names, no message content, nothing to hand over even if compromised. PyNaCl + ChaCha20, forward secrecy via Sender Keys ratchet, TLS + TOFU on transport.

value: Show HN: NoEyes – Terminal chat where the server is architecturally blind

author: Ymsniper


value: newtechwiz

value: Show HN: Local-first dictation for macOS – Parakeet TDT, zero cloud calls

author: newtechwiz


value: Show HN: Phantom – Let AI use your API keys without leaking them


value: promptfluid

value:
I’m a solo founder. I built a Cognitive Infrastructure Substrate — pure algorithmic code, zero AI API calls inside, no OpenAI dependency, fully patentable. A discovery engine collides software primitives against each other and crystallizes viable configurations into production-ready code.
It has autonomously discovered over $4.3B in software capabilities. I didn’t write what I’m sharing. The substrate found it.
Neural Arbiter — CJPI 100 | Governance | $3M substrate valuation
One sentence: an AI decision-making system that cannot issue a verdict without first passing through an ethics assessment.
ANALYTICS → BRAIN → CONSCIENCE → GOVERNANCE → SOVEREIGN
That sequence is enforced by the pipeline. You can’t skip conscience. Ethical assessment before enforcement — architecturally, not as an audit afterthought. In a world where the EU AI Act is landing now, that’s not a feature. That’s the pipeline regulators are describing in legislation.
Full code (one file, zero dependencies):
https://pastebin.com/54QhPiwZ
I’m giving one free discovery away every day at random times right here on HN until I hit 1000 users.
Currently at 42.
Comment below if you want a specific software type — security, synthesis, cognitive, governance.
I’ll run the discovery engine with your parameters and post the result tomorrow.
958 to go.
CMPSBL.com — NPM with persistent memory online.

value: Show HN: CMPSBL Software Factory — Free Daily Drop $2.9M

author: promptfluid


value: evanvuckovic

value:
Anthropic says on their safety page: "these filters are not a security boundary." Snyk found 36% of ClawHub skills contain security flaws. Trend Micro documented malware being distributed through ClawHub.
These agents have shell access, file access, and connected accounts. We built Shoofly to sit in front of tool calls before they fire.
- PreToolUse / PostToolUse hooks intercept every tool call
- Blocks prompt injection, credential theft, unauthorized writes, malware in tool results
- Works with OpenClaw, Claude Code CLI, and Cowork / Dispatch
- Open YAML policy -- read it, fork it, audit it
- Free tier detects. $5/mo blocks.
The Cowork piece was the interesting part. Cowork runs Claude Code inside a full Ubuntu VM -- host hooks don't fire there. We used the plugin system with hooks/hooks.json and VirtioFS to get sub-50ms alert latency from inside the VM to host notifications.
curl -fsSL https://shoofly.dev/install.sh | bash
shoofly.dev

value: Show HN: Shoofly – pre-execution security for Claude Code Cowork and OpenClaw

author: evanvuckovic


value: gpavanb

value: Show HN: Repeat After Me – Read aloud your favourite books in global languages

author: gpavanb


value: sthottingal

value:
A developer's machine accumulates tools fast. A Rust CLI you compiled last year, a Python formatter installed via `uv`, a language server pulled from npm, a terminal emulator from a curl script, a Go binary built from source. Each came from a different package manager, each with its own install incantation you half-remember.
I wanted a way to declare what I need without adopting a complex system like Nix or Ansible just for a single laptop. The result was a plain old Makefile.
I wrote a short post on using Make (along with a tiny bash script and fzf) to create a searchable, single-command registry for all your local dev tools. It’s not a new framework or a heavy tool—just a simple way to organize the package managers we already use.
If you're tired of losing track of your local environment, you might find it useful.

value: Show HN: Home Maker: Declare Your Dev Tools in a Makefile

author: sthottingal


value: just-claw-it

value: Show HN: Built tool to turn n8n workflows into OpenClaw-compatible agent skills

author: just-claw-it


value: nhirschfeld

value: Show HN: Liter-LLM, Universal LLM client in Rust with bindings for 11 languages

author: nhirschfeld


value: qwertykb

value: Show HN: Public transit systems as data – lines, stations, railcars, and history

author: qwertykb


value: veganmosfet

value: Show HN: Prompt Injection Experiments in OpenClaw with Opus4.6

author: veganmosfet


value: RichardOdds

value: Show HN: Ayush Agarwal the guy that built a better Stripe Alternative

author: RichardOdds


value: kuberwastaken

value: Show HN: Litmus – Run a Parallel Autonomous ML Research Org on Your OpenClaw

author: kuberwastaken


value: crackeddude

value:
Before reading text please try the app https://www.whattobuy.app (to get great UX feedback)
Shopping research is one of the most challenging tasks and people spend 30-60 min before buying an item. We developed a platform called “WhatToBuy” to save people time. In some cases shoppers are not super aware of what to really order for a trip or occasion. Our app helps them to get a range of products needed for each use-cases hence saving time and money.
App workflow: Describe your situation in plain English. In Fast mode, you get three ready-to-shop carts: Budget, Balanced, and Premium with real products, real prices, and direct buy links. In Deep mode, AI assistant has a conversation with you first and builds a single cart tailored specifically to your answers.
How it works:
* You type something like "camping weekend with two young kids" or "setting up a home office on a tight budget"
* AI assistant (powered by Claude) parses the scenario and generates a list of specific product search queries. For example, in the above query for camping, product search will be "tent 4-person easy setup" instead of simply "tent".
* Those queries hit Shopping API and return real-time results.
* A scoring layer ranks by price, rating, and review count to pick one winner per product category per tier.
Two modes:
* Deep (default): AI assistant asks a few follow up questions before building a single personalized cart. We default to this because more context means dramatically better picks. Sign in is required for this mode, but you can always drop back to Fast mode with one click.
* Fast: Instant three-tier carts, no sign in needed, works right away.
Please take a look: https://www.whattobuy.app
No account needed to try the fast mode. Would love feedback on where the recommendations miss or where the UX feels off.

value: Show HN: WhatToBuy – Describe your situation, get AI-curated shopping carts

author: crackeddude


value: masahito

value: Hello, something I built for fun - a sandbox where you can play around with conveyor belts, pneumatic tubes and boxes. A bit like marble run. You can toggle to dev mode to drag things around, add new elements, delete them. I guess you can also type out the config manually (they're not that complex). You can also save configs as text files and re-upload them to load.

value: Show HN: Interactive sandbox with boxes, conveyor belts and pneumatic tubes

author: masahito


value: Show HN: TurboQuant for vector search – 2-4 bit compression


value: Show HN: Voxi.fm – Listen to articles that don't sound like a robot reading


value: georgestrakhov

value:
Hi HN!
I've been very unimpressed with how LLMs think when it comes to anything creative. It's no surprise - they've been lobotomized by RLHF to be helpful, predictable and consistent - all of these things are counterproductive in a more creative setting.
So I've built a little something to help LLMs be less creatively bland and dumb. It's called ThinkFu (because I believe creative thinking, when practiced well, is a martial art).
Anyway, you can watch a 3-min video demo here: https://www.youtube.com/watch?v=x-LQvX105SI
Or you can just add it to your claude code like this:
/plugin marketplace add move38studios/thinkfu
/plugin install thinkfu@move38studios-thinkfu
You can also explore what's happening in the code here:
https://github.com/move38studios/thinkfu
The TL;DR is:
1. I've collected 200+ "thinking moves" from things like oblique strategies, triz, systems thinking, design thinking etc. and adapted them for LLMs
2. I've added a little randomness with variables, so that the total number of moves that you can get is somewhere around 500 billion. Because in creative thinking randomness is a feature not a bug.
3. There is a vector search and a tiny LLM router (behind an MCP) that tries to get you the right "thinking move" for whatever your problem may be.
Everything runs on cloudflare (still love you guys, despite all the recent issues).
Oh, also on first use you can opt in or out of sending the anonymized ratings back to my endpoint. The idea is that the LLM (or user) can rate whether a certain move was productive or not in a certain context.
If I collect enough ratings, I'll finetune a custom LLM for the router and I think routing will get better as a result.
Hope y'all find it interesting!
I'd be happy to answer questions and get bug reports and PR requests and what not. It's a tiny experiment - but if it works it could be fun to scale with the community.

value: Show HN: Think Fu – Metacognition as a service

author: georgestrakhov


value: Show HN: Sheet Ninja – Google Sheets as a CRUD Back End for Vibe Coders


value: Show HN: PromptLedger – local-first prompt versioning in SQLite


value: clebert

value:
I built a watchface inspired by Pink Floyd's "Dark Side of the Moon". A prism that refracts light into a rainbow to show the time. The minute hand is a light ray, the rainbow points at the hour.
It's written in Zig, which lets me target the browser (WASM), a Raspberry Pi Zero 2 W driving a 13.3" e-ink display as a wall clock, a Pico 2 for bare-metal battery operation, and eventually the Pebble Round 2 smartwatch.
I built it with Claude Code (Opus) as an experiment in AI-assisted coding while keeping real ownership of the code. Claude does the fast iteration, I make the architecture decisions and refactor by hand. Every line in lib/ is reviewed and curated.
The rendering went through a few iterations. Started with physical dispersion using Cauchy's equation, but tuning the coefficients for all 720 time combinations was a nightmare and some just looked bad. Then I tried bouncing light inside the prism, which was better but had ugly corner cases. In the end I dropped the physics and went with a simple traced path that always looks good.

value: Show HN: Ticking Away, a Dark Side of the Moon Watchface Written in Zig

author: clebert