value: adithyadrdo

value:
Hey everyone,
I’ve been working on a project called L88 — a local RAG system that I initially focused on UI/UX for, so the retrieval and model architecture still need proper refinement.
Repo:
https://github.com/Hundred-Trillion/L88-Full
I’m running this on 8GB VRAM and a strong CPU (128GB RAM). Embeddings and preprocessing run on CPU, and the main model runs on GPU. One limitation I ran into is that my evaluator and generator LLM ended up being the same model due to compute constraints, which defeats the purpose of evaluation.
I’d really appreciate feedback on:
Better architecture ideas for small-VRAM RAG
Splitting evaluator/generator roles effectively
Improving the LangGraph pipeline
Any bugs or design smells you notice
Ways to optimize the system for local hardware
I’m 18 and still learning a lot about proper LLM architecture, so any technical critique or suggestions would help me grow as a developer. If you check out the repo or leave feedback, it would mean a lot — I’m trying to build a solid foundation and reputation through real projects.
Thanks!

value: Show HN: L88 – A Local RAG System on 8GB VRAM (Need Architecture Feedback)

author: adithyadrdo


value: chncwang

value: Show HN: ClinTrialFinder –AI-powered clinical trial matching for cancer patients

author: chncwang


story_text:
Hey everyone,
I’ve been working on a project called L88 — a local RAG system that I initially focused on UI/UX for, so the retrieval and model architecture still need proper refinement.
Repo:
https://github.com/Hundred-Trillion/L88-Full
I’m running this on 8GB VRAM and a strong CPU (128GB RAM). Embeddings and preprocessing run on CPU, and the main model runs on GPU. One limitation I ran into is that my evaluator and generator LLM ended up being the same model due to compute constraints, which defeats the purpose of evaluation.
I’d really appreciate feedback on:
Better architecture ideas for small-VRAM RAG
Splitting evaluator/generator roles effectively
Improving the LangGraph pipeline
Any bugs or design smells you notice
Ways to optimize the system for local hardware
I’m 18 and still learning a lot about proper LLM architecture, so any technical critique or suggestions would help me grow as a developer. If you check out the repo or leave feedback, it would mean a lot — I’m trying to build a solid foundation and reputation through real projects.
Thanks!

title: Show HN: L88 – A Local RAG System on 8GB VRAM (Need Architecture Feedback)


value: parkaboy

value: Show HN: enveil – hide your .env secrets from prAIng eyes

author: parkaboy


value: meszmate

value:
Hey HN. I built memctl because every AI coding agent starts each session with zero context. No memory of past decisions, no shared knowledge across your team.
memctl is a memory server that gives AI coding agents persistent context that carries over across sessions. Memory is shared across your team so every agent works with the same knowledge. It's branch-aware so context follows your git workflow, and everything is tracked with full history.
It works with any AI coding agent. Open source and self-hostable.
GitHub: https://github.com/memctl
Website: https://memctl.com
Launches on March 1st. Waitlist open.
Would to hear any feedback!

value: Show HN: Memctl.com: Open-source shared memory infrastructure for coding agents

author: meszmate


value: PhiniteAI

value: Show HN: Describe a workflow in plain English and builds the multi-agent system

author: PhiniteAI


value: primaprashant

value:
Ran a hands-on workshop in Tokyo where ~50 engineers built a CLI coding agent from scratch in Python and now, I've converted it into a self-paced exercise.
GitHub Repo: https://github.com/primaprashant/alduin
This should help in getting a better understanding of what goes on inside the coding agents. You will iteratively implement the core agent loop present in all coding agents like Claude Code and Codex starting from a skeleton repo with a basic input loop and no LLM. Over 7 phases, you will add the Anthropic API and implement tools (read file, edit file, bash). Each phase has hints and a reference implementation if you get stuck.
Should take ~3-5 hours and in the end, you'll have your own coding agent which you can use on other project and codebases as well.
Feedback and PRs welcome. Happy to answer any questions.

value: Show HN: Build Your Own CLI Coding Agent in Python

author: primaprashant


value: sahiljagtapyc

value:
Hey HN,
I built AgentBudget after an AI agent loop cost me $187 in 10 minutes — GPT-4o retrying a failed analysis over and over. Existing tools (LangSmith, Langfuse) track costs after execution but don't prevent overspend.
AgentBudget is a Python SDK that gives each agent session a hard dollar budget with real-time enforcement. Integration is two lines:

    import agentbudget
    agentbudget.init("$5.00")

It monkey-patches the OpenAI and Anthropic SDKs (same pattern as Sentry/Datadog), so existing code works without changes. When the budget is hit, it raises BudgetExhausted before the next API call goes out.
How it works:
- Two-phase enforcement: estimates cost pre-call (input tokens + average completion), reconciles post-call with actual usage. Worst-case overshoot is bounded to one call.
- Loop detection: sliding window over (tool_name, argument_hash, timestamp) tuples. Catches infinite retries even if budget remains.
- Cost engine: pricing table for 50+ models across OpenAI, Anthropic, Google, Mistral, Cohere. Fuzzy matching for dated model variants.
- Unified ledger: tracks both LLM calls and external tool costs (via track() or @track_tool decorator) in a single session.
Benchmarks: 3.5μs median overhead per enforcement check. Zero budget overshoot across all tested scenarios. Loop detection: 0 false positives on diverse workloads, catches pathological loops at exactly N+1 calls.
No infrastructure needed — it's a library, not a platform. No Redis, no cloud services, no accounts.
I also wrote a whitepaper covering the architecture and integration with Coinbase's x402 payment protocol (where agents make autonomous stablecoin payments): https://doi.org/10.5281/zenodo.18720464
1,300+ PyPI installs in the first 4 days, all organic. Apache 2.0.
Happy to answer questions about the design.

value: Show HN: AgentBudget – Real-time dollar budgets for AI agents

author: sahiljagtapyc


value: Alexpinkone

value: Show HN: Cord – Constitutional AI enforcement engine for autonomous agents

author: Alexpinkone


value: Show HN: Chemistry Lab Simulator (for AS Level)


value: justincxa

value: Show HN: Multi-Agent Simulations for Assumption Testing and Analysis (Free)

author: justincxa


value:
Hi HN,
I have been building mobile apps for about 8 years now. I built a tool iOS app to just transcribe and summarize audio recordings, meetings, lectures, seminars, doctor appointments, project showcase, event, journalism etc. It can unlimited record and transcribe, summarize and get key data, AI chat with transcription, youtube video to transcript and summary.
The goal was to make something completely frictionless. There is no login required. You just open it and start recording, or paste a YouTube link to get the full transcript and AI summary instantly without having to watch the video.
Under the hood, I am using the Gemini API with a custom model for the heavy lifting. The audio is kept on your device, sent to the API for processing, and then deleted within 24 hours. It is definetly not used for training any models.
Main features:
Audio recording and file import
YouTube video to notes and summaries
Chat directly with your transcripts to find specific info
Supports over 100 languages
Unlimited recording hours (I am trying to make the math work on a flat subscription rather than charging users per minute)
Flash Cards and quiz based on transcript for learners.
Since I just launched it a few days ago, I am really looking for feedbacks. Free generation and free trial is also available.
Thanks.

value: Show HN: I built an AI Voice note taker transcriber


value:
Scheme-langserver digest incomplete Scheme code to serve real-world programming requirements, including goto-definition, auto-completion, type inference and such many LSP-defined language feature supports.  And this project is based here(https://github.com/ufo5260987423/scheme-langserver).
I built it because I was tired of Scheme/Lisp's raggy development environment, especially of the lack of IDE-like highly customized programing experience. Though DrRacket and many REPL-based counterparts have don't much, following general cases aren't reach same-level as in other modern languages:
(let* ([ready-for-reference 1]

         [call-reference (+ ready-for-)]))

Apparently, the  `ready-for-` behind `call-reference` should trigger an auto-complete option, in which has a candidate `ready-for-reference`.  Besides, I also know both of them have the type of number, and their available scope is limited by `let*`'s outer brackets. I wish some IDE to provide such features and such small wishes gradually accumulated in past ten years,  finally I wasn't satisfied with all the ready-made products.
If you want some further information, you may refer my github repository in which has a screen-record video showing how you code get help from this project and this project has detailed documentation so don't hesitate and use it.
Here're some other things sharing to Hacker News readers:
1. Why I don't use DrRacket: LSP follows KISS(Keep It Simple, Stupid) principle and I don't want to be involved with font things as I just read in its github issues.
2. What's the newest stage of scheme-langserve: It achieves kind of self-boost, in which stage I can continue develop it with its VScode plugin help.  However, I directly used Chez Scheme's tokenizer and this leaded to several un-caught exceptions whom I promise to be fixed in the future, but I'm occupied with developing new feature. If you feel something wrong with scheme-langserver, you may reboot vscode, generally this always work.
3. Technology road map: I'm now developing a new macro expander so that the users can customize LSP behavior by coding their own macro and without altering this project. After this, I have a plan to improve efficiency and fix bugs.
4. Do I need any help: Yes. And I'd like to say, talking about scheme-langserver with me is also a kind of help.
5. Long-term View: I suspect  2 or 3 years later I will lose concentration on this project but according some of my friends, I may integrate this project with other fantastic work.

value: Show HN: Scheme-langserver – Digest incomplete code with static analysis


value: siy

value:
Author here. I built this because after years of watching teams spend more time fighting Kubernetes YAML, service meshes, and Spring Boot startup than writing business logic, I wanted to see if the JVM itself could be the platform.
Aether is a standalone distributed runtime for Java 25. You write "slices" (small focused handlers), package them as JARs, and Aether handles clustering, deployment, routing, rolling updates, auto-healing, and auto-scaling. No containers, no sidecars, no orchestrator.
Under the hood: Rabia consensus for replicated state, consistent hash ring DHT for artifact storage and distributed cache, blueprint-based deployment with traffic shifting, and CPU-based auto-scaling with optional ONNX-based predictive scaling.
Performance: 4K RPS at ~0.5ms latency (localhost, Mac M1 Air), 10K req/s distributed. Survives rolling restarts with ~100% request success.
Just released 0.17.0 with pub-sub messaging, scheduled invocations (cron + interval), DHT anti-entropy repair, and cluster event streaming.
59 features complete, 80+ E2E tests, 427+ unit tests. Not claiming production-ready for unsupervised use yet -- no RBAC (coming in 0.18.0), no KV-Store backup. Ready for controlled pilots.
Core library and tooling are Apache 2.0. Aether runtime is BSL 1.1 (free for internal use at any scale, converts to Apache 2.0 in 2030).
1-min demo: https://www.awesomescreenshot.com/video/49013877?key=a0b1105...
Happy to answer questions about the architecture or the "JVM as platform" approach.

value: Show HN: Pragmatica Aether – a distributed Java runtime that replaces Kubernetes

author: siy


value: machomillions

value: Show HN: Suplex – All-in-one cold email (leads, sending, CRM)

author: machomillions


value: ellenajt

value: Coding agents are addictive and I stay up too late playing with them.<p>This hook makes Claude code nudge me to go to sleep when it's past my bedtime. It works! Goodnight! :)

value: Show HN: A Claude Code hook that sends you to bed

author: ellenajt


value: Show HN: Notion-CLI – Full Notion API from the terminal, 39 commands, one binary


value: chetansorted

value:
I built FitSaver — an iOS app that imports workout videos and converts them into structured routines you can actually follow.
It’s not trying to compete with trainers or AI coaching apps. It solves a simpler problem: people save workouts, but rarely turn them into usable plans.
Some interesting things I’ve learned since launching in early January:
Most paying users are 35–55, not 20-somethings.
The biggest pain point isn’t discovering workouts — it’s organizing and following them.
Users describe it as a “workout video compiler,” which wasn’t language I initially used but turned out to be accurate.
Several reviews mention that scrolling at the gym is the real friction.
A few actual user quotes:
“Other apps just have set workouts that aren’t as customizable as I’d like — this app provides that customization.”
“I scroll Instagram all the time and saving workout ideas is a mess. This was super helpful.”
“There’s nothing worse than scrolling social media or notes in a busy gym. This solves that problem.”
The app is currently search-driven (App Store search is ~60% of downloads), so I’m mostly focused on product and retention rather than paid marketing.
Would love feedback on:
Whether this problem resonates outside fitness
If organizing saved content into structured systems is a broader pattern
What you’d build next in this niche
Happy to answer technical or product questions.

value: Show HN: I built iOS app to turn saved workout videos into structured routines

author: chetansorted


value: isuatfurkan

value:
Hey HN,
I built ImgPakt because every image compressor I found uploads files
to a server. TinyPNG, Compressor.io, iLoveIMG — they all require
sending your images over the internet.
ImgPakt compresses images entirely in the browser using Canvas API
and Web Workers. There's no fetch(), no XMLHttpRequest, no upload
endpoint in the code. Files literally cannot leave your device.
Technical details:
- FileReader → offscreen Canvas → toBlob() at target quality
- Web Workers keep the UI thread free during batch processing
- Supports JPEG, PNG, WebP, AVIF
- 5 preset quality profiles instead of a manual slider
Free tier: 5 images per batch, all profiles.
Pro ($3.99/mo): unlimited batch, format conversion, AVIF.
I'd appreciate any feedback on the compression approach or UX.
Happy to answer questions about the architecture.

value: Show HN: ImgPakt – Client-side image compressor, nothing leaves the browser

author: isuatfurkan


value:
I built a system that reads research papers across unrelated domains and tries to surface hypotheses that neither field would have generated on its own.
The Discover page is where it publishes findings: https://aegismind.app/discoveries
It's very early — only three discoveries so far — but the core idea is what I want feedback on.
The problem it's trying to solve:
Science is siloed. A breakthrough in mycology might have direct implications for network routing. A discovery in chronobiology might reframe how we think about database consistency. Nobody reads across all of it, and even when they do, the connection is usually accidental.
How it works:
The autonomous "Right Brain" service ingests papers across domains continuously
Multiple models (GPT, Claude, Gemini, Mistral, Grok) analyze papers in parallel
A synthesis layer looks for structural or mechanistic similarities across domain boundaries
Hypotheses are only published when they pass a novelty and coherence threshold — it won't surface things either field already knows
What I'm genuinely uncertain about and want feedback on:
How do you evaluate whether a cross-domain hypothesis is actually interesting vs. superficially pattern-matched? This is the hardest part of the novelty filter.
Which domain combinations would you most want to see? (We're currently not curating this — it's whatever the system finds structurally similar.)
Should findings link directly to the source papers?
Only three discoveries published so far, so the page is sparse — but I'd rather share the idea early than wait until it looks polished.

value: Show HN: AegisMind Discover – cross-domain hypothesis generation from papers


value: jayhowye

value:
Hi HN,
I built VVMList for cybersecurity learners to easily find specific techniques used on specific machines.
A few years ago, I originally created VVMList to track the machines I completed and the techniques I used to solve them. After some time, I semi-abandoned the project.
At the end of 2024, I revisited the idea and decided to expand it into something bigger. More like a structured "ctf bible" for learners who want to study techniques in a more organized way.
For this, I read through many machine writeups from Vulnhub, HackMyVM, VulNyx and HackTheBox. I extracted and categorized the techniques used in each machine.
This process led to VVMList v3. when I first started, the project included around 250 machines. With v3, it grew to over 1200 machines, which allowed me to reach the original scope I had in mind.
In the 2026 annual update (v3.2), I added newly released machines from the platforms, integrated ctfmirror.com (my another project) for all machine images and integrated archive.org for all writeups. The goal was to provide a more centralized solution and reduce the risk of resources disappearing over time.
I'd really appreciate feedback from the community. Does the structure make sense? Are there techniques or machines that you think are missing? Any suggestions to improve usability or make it more useful for learners are very welcome.
Thanks for taking a look.

value: Show HN: VVMList – Vulnerable VMs organized by attack techniques

author: jayhowye


value: umeonigiri

value: Show HN: Optimizing reading for fluency in Japanese through genre-specific media

author: umeonigiri


value: marstay

value: Show HN: ConsentCheck, Consent Mode v2 scanner with monitoring alerts

author: marstay


value:
We like OpenClaw, but setup is still too hard for many non-technical users.
EasyClaw is a one-click OpenClaw deployment service: https://www.easyclaw.pro
A short setup flow lets you choose a model provider and connect channels like Telegram, Discord, or WhatsApp. After that, your assistant can go live without managing VPS, Docker, or updates.
It's designed to be friendly for non-technical users, while still fast for developers who just want a simple deployment path.
Would love feedback on:
- pricing clarity
- trust/security messaging
- onboarding friction

value: Show HN: EasyClaw – one-click OpenClaw deployment for non-technical users


value: glidea

value:
I posted an Ask HN about forcing myself to take breaks. Got some great responses (drink water, get a cat, etc).
I ended up building the tool I mentioned – ForceBreak. Now it's on the App Store.
Core idea: full-screen overlay + cooldown before you can skip. Those few seconds are enough to make you think twice.
Native Swift, lives in menu bar, minimal footprint.
Would love to hear what you think.
https://apps.apple.com/app/forcebreak/id6758971359

value: Show HN: ForceBreak – A Break Reminder with Friction

author: glidea


value: mikeyfrilot

value: Built this as an experiment in giving LLMs embodied musical experience. It's an MCP server with 120 MIDI songs across 12 genres. Each genre has one fully annotated exemplar the model studies first. The rest are raw MIDI waiting to be learned.<p>The model can read sheet music, play songs through your speakers, view an SVG piano roll it can read back to verify what it played, and write to a practice journal that persists across sessions. Learning compounds over time.

value: Show HN: AI Jam Sessions – MCP server that teaches AI to practice piano

author: mikeyfrilot


value: rhelm-ai

value:
Hey HN. I've spent 10 years doing IT work, mostly infrastructure and scripting, the stuff nobody writes blog posts about. No CS degree. This is my first startup and I have no idea if I'm doing it right.
Here's the problem that bugged me: every AI agent setup I looked at just blasts everything through GPT-4 or whatever the biggest model is. That's insane for 80% of tasks. You don't need a $0.03/1k token model to parse a CSV.
So I built two things. Rhelm is a web app for organizing AI work visually, boards and tasks, kind of like Linear but for agent workflows. goClaw is a companion mobile app (coming to App Store and Play Store) that lets you talk to your agents from your phone. Text or voice. "Hey, spin up the data cleaning job" and it figures out which model to route it to based on what the task actually needs.
The routing is the part I care about most. Task comes in, system looks at complexity, picks the cheapest model that can handle it. Sometimes that's a local model, sometimes it's an API call, sometimes it's "this actually needs a human." I built the core loop in about 4 days. I've been breaking and fixing it since.
I'm not going to pretend I have everything figured out. I definitely don't. But I'm mass rounding off the rough edges and I'd rather ship something and learn from people smarter than me than sit on it forever.
https://rhelm.io (waitlist is open)
What am I missing? What would make you actually use something like this?

value: Show HN: Built an AI tool that routes tasks to agents, humans. Am I crazy?

author: rhelm-ai


value: benriazy

value: Show HN: Autonomous AI Agent Fleets

author: benriazy

title: Show HN: Autonomous AI Agent Fleets


value: crawdog

value:
I read Cloudflare's "Markdown for Agents" article and thought this would be really powerful if it could support internal websites, JSON content and dynamic Javascript sites.
I built this on my 35-minute BART ride to SF using my phone as the IDE (and a couple of hours of feature creep/testing). It's a combination MCP server + HTTP proxy that converts web content to markdown on-the-fly.
Key features:
* HTTP/HTTPS proxy with automatic HTML to markdown conversion
* Token counting and caching to stay efficient
* Content negotiation (only converts when Accept: text/markdown)
* MCP server
* JavaScript rendering for dynamic sites
Let me know what you think!

value: Show HN: Markdown in the Middle – proxy to convert HTML to Markdown

author: crawdog


value: juhrjuhr

value:
Hello,
This is my game, it's a tiny dungeon crawler played in the Windows file explorer. Your player character is a folder that you drag and drop into other folders to move, items are equipped by dropping them into your equipment folder, some items are used by deleting them, and monsters can be looted for their files.
I got the idea to do something in the file explorer after I saw this version of Flappy Bird in the Mac finder:
https://github.com/nolenroyalty/flappy-dird
It was fairly straight forward to make, using just a file watcher, shortcuts, and (optionally) Window's explorer API to detect whether the player folder is open in an explorer window (to delay renaming the folder until it's not used). It only uses files and folders it creates itself, and doesn't look outside of its executable's folder.
The project lent itself very well to TDD, especially since there are a lot of interactions that are quite tedious to manually test again and again.
It's also available on Itch (no account required):
https://juhrjuhr.itch.io/directory-dungeon

value: Show HN: An RPG in the Windows file explorer

author: juhrjuhr


value: rishi-sharma

value:
Hello Everyone,
I built vim-claude-code, a lightweight Vim plugin that lets you interact with Claude directly inside Vim through a split window.
The goal was to avoid leaving the editor to ask questions, refactor snippets, or generate code. I wanted something that feels native to Vim instead of context-switching to a browser or separate app.
What it does:
Opens a split window for Claude's responses
Sends selected code or custom prompts
Displays responses directly in Vim
Supports normal Vim navigation and scrolling
Minimal setup with no heavy UI layer
It’s still early and intentionally simple. I’d really appreciate feedback from Vim users, especially around workflow, keybindings, and split behavior. Happy to discuss tradeoffs and improvements.
GitHub: https://github.com/rishi-opensource/vim-claude-code
Thanks!

value: Show HN: Vim-Claude-code – Use Claude directly inside Vim

author: rishi-sharma


value: eriknielsen

value:
Show HN: Kuta – Treadmill interval training for iOS
https://getkuta.com
I kept losing count of reps during treadmill intervals. Tried paper notes, tried the big running apps – none of them are really built for treadmill use.
Kuta guides you through workouts with large visual cues (designed for sweaty hands on a bouncing treadmill), calculates distance from pace × time instead of the treadmill sensor, and syncs to Strava via Apple Health.
SwiftUI, iOS 17+. 22 free preset workouts. Custom workouts are a one-time $2.90 unlock. No subscription.
This is my first app. Got rejected by Apple twice before approval. Happy to talk about the build or the process.

value: Show HN: Kuta – Treadmill Interval Training for iOS

author: eriknielsen


value:
I’ve been a fandom writer for a long time and also a very deep Tumblr user (like… headcanons, incorrect quotes, character analysis at 2am kinda deep). Writing has always been how I have fun w/ characters and stories I love.
I’m also a dev, and at some point I noticed smth pretty obvious: I love writing, but inspo doesn’t always show up when I want it to. Sometimes I really wanna write headcanons or relationship stuff, but my brain just goes empty lol.
So I ended up building a small tool for myself.
It’s an AI headcanon generator — you give it a few prompts, and it can generate character headcanons, relationship dynamics, random moments, or incorrect quotes. It’s not meant to replace writing or anything, more like a brainstorming buddy when you’re stuck or just wanna mess around.
I’m sharing it here bc it actually helped me get unstuck and made writing feel fun again, and I figured other fandom writers / Tumblr ppl might enjoy it too.
If anyone wants to check it out, here’s the link:
https://aiheadcanongenerator.org/
Would love feedback, ideas, or feature requests — esp from ppl who live in fandom spaces.

value: Show HN: AI Headcanon Generator: Instant Ideas, Endless Stories


value: Show HN: AI tools on one domain, built with Next.js and Claude AI


value: paraschopra

value:
Hi HN,
Over the weekend, I built a Chrome extension that transforms your ChatGPT and Claude conversation topics into beautiful, animated black-and-white visualizations on every new tab.
How It Works
- Scrapes conversation titles from ChatGPT and Claude sidebars via content scripts
- Generates self-contained HTML/CSS/JS art pieces via OpenRouter LLM API
- Displays art in a sandboxed iframe on every new tab, biased towards recent pieces (exponential decay with factor 0.95). The refresh button picks uniformly at random from all stored art. Up to 100 artifacts are kept.
Hope you like it! It's been three days for me, and I keep getting surprised by the generations I see :)
Note: you'll require an OpenRouter key and that it may cost ~$5/mo for generating 3 visuals/day with Sonnet 4.6.

value: Show HN: Murmuration – AI visualizes your state of mind

author: paraschopra


value: Show HN: Use this to optimise your CV

title: Show HN: Use this to optimise your CV


value:
I developed a Python JSON library, ssrJSON, built on the yyjson codebase and SIMD techniques. It can serve as a compatible replacement for most common JSON use cases, and benchmarks show it outperforms orjson, which advertises itself as the fastest. Compared with other Python JSON libraries, ssrJSON addresses UTF-8 cache related performance pitfalls, giving it a significant advantage when handling strings; technical details are available on my blog: https://en.chr.fan/2026/01/07/python-json/. In addition, for floating‑point handling ssrJSON uses the latest zmij algorithm.
I noticed that orjson has closed its issue tracker: https://news.ycombinator.com/item?id=47022606. If the community wishes to maintain a stable, high‑performance JSON parser, ssrJSON could be considered as an alternative.

value: Show HN: SsrJSON: faster than the fastest Python JSON library


value: Show HN:Agentic Browser Automation – Lightweight Selenium and Claude Code Bridge


value: lorengarcialv

value:
Hey HN,
I built DYPAI a backend platform where you describe what you
need to your AI assistant (via MCP) and it builds the entire
backend for you.
Instead of writing API routes or edge functions, your backend
is a composition of nodes: database queries, Stripe payments,
emails, Slack, WhatsApp, AI agents, logic – all connected as
flows and exposed as production API endpoints.
One prompt, one endpoint: validate input → check permissions →
query DB → transform data → send email → notify Slack → respond.
No code. No deploy. Just works.
You can build from Cursor/Claude via MCP, see everything on a
visual canvas, or use the REST API and TypeScript SDK directly.
It's in public beta so rough edges are expected – that's exactly
why I'm sharing it here.
Demo video: https://www.dypai.ai/
Looking for feedback. Happy to answer anything.

value: Show HN: Dypai – Build backends from your IDE using AI and MCP

author: lorengarcialv


value:
hey hn,
i built beehive for myself mostly. it has gotten to the point where my work consists in supervising oc or cc labor at tasks for multiple issues in parallel. my set up used to be zellij with a couple tabs, each tab working in a separate dir and it was a pain to manage all that. i know i could use git worktrees but they're kind of complicated, if you don't know how to use them it is easy to mess up, and i just prefer letting agents run in separate dirs with their own .git and not risk it. while i like zellij and use it inside beehive, i dont like the tabs and i forget where i am half the time.
beehive is a way for me to abstract that away. the heuristic is simple - hives are repos, so you basically have a bunch of hives which correspond to repos you work out of. each hive can have many combs. a comb is a dir with the copy of the repo you're working on. fully isolated, standalone, no shared .git. so for work or for personal stuff, i usually set up the hive, and then have a bunch of combs that i jump between supervising the agents do their thing. if you have a big repo it takes a minute to clone, and you also need gh and git because i like the niceties of like checking if the repo is there at all and stuff like that.
the app is open source, mit license. i went with tauri because i hate electron. also i have friends and coworkers who updated to macos 26 and i dont know if the whole mem leak thing for electron apps has been fixed. the app is like 9 megs which is nice too. most of it is written with cc, but i guided the aesthetics and the approach. works on mac and there is a dmg signed and notarized (i reactivated my apple dev credentials).
sharing this to get a vibe check on the idea, also maybe this is useful for you. there are many arguments, reasonable ones, you can make for worktrees vs dirs. i just know that trees are too big brain for me, and i like simple things. if you like it, pls lmk and also if you want to help (like add linux support, or like add themes, other cool things) please make a pr / open an issue.

value: Show HN: Beehive – Multi-Workspace Agent Orchestrator


value:
I wrote a guide on integrating Playwright into the three most common CI systems. It covers what each platform actually requires to run Playwright reliably: browser dependency handling, playwright.config.ts CI settings, parallel sharding, and artifact collection for failed tests.
The core issue most teams hit: default CI images don't ship with the system libraries Playwright browsers need (GTK, NSS, ALSA). The guide covers both approaches — Playwright's official Docker image versus manual --with-deps install — and when each makes sense.
Each platform section includes a working config file you can copy directly:
GitHub Actions: YAML with matrix sharding across 4 runners
Jenkins: Jenkinsfile using Playwright's Docker image as the agent
GitLab CI: .gitlab-ci.yml with the native parallel keyword
Also covers playwright.config.ts settings that break in CI if you ignore them: forbidOnly, retry count, worker count, and trace collection strategy.
Full article here: https://testdino.com/blog/best-playwright-ci-cd-integrations...
Happy to answer questions on any of the platform-specific setup steps.

value: Show HN: Playwright CI/CD in GitHub Actions, Jenkins, and GitLab CI


value: prbdias

value:
Hey HN, I've been exploring ways to make my engineering teams more productive in multi-agent AI coding workflows.
The most popular development tools (Cursor, Claude Code, etc.) leverage git worktrees to enable multiple agents to work in parallel, guaranteeing each runs in a semi-isolated workspace. The workflow is powerful, but switching between worktrees to test what each agent built is painful: take down the stack for agent X, cd to the right worktree, re-source .env files, bring up the stack for agent Y, run migrations, seed the database, start build tools... every single time.
forest solves this with a single command. It's a portable Bash script (~1200 lines, no dependencies beyond git/docker/jq) that bridges git worktrees, Docker Compose, and host services:

  - forest list — shows all worktrees with branch context, dirty file counts, and issue numbers parsed from branch names
  - forest boot 2 — spins up the full dev stack (Docker + host services like Vite) for worktree #2
  - forest switch 3 — tears down the current stack and boots another in seconds
  - forest status — shows exactly what's running and where

It also has a configurable hook system (pre, pre-services, post) so you can automate all the ceremony around booting an environment. Running migrations, seeding or resetting databases, installing dependencies, setting up k8s clusters, health checks, whatever your project needs. It auto-sources .env files, redirects host service logs to .forest/logs/, and remembers branch names even when worktrees end up in detached HEAD state (common during agent rebases).
Config is a single JSON block that lives alongside your editor config (auto-detects from .cursor/worktrees.json, .claude/settings.json, or .forest/config.json), and forest init walks through setup interactively.
Pure Bash 3.2+ (works on macOS out of the box), MIT licensed. Install with:

  curl -fsSL https://raw.githubusercontent.com/prbdias/forest-cli/main/install.sh | bash

Would love feedback from anyone doing multi-worktree development, with or without AI agents.

value: Show HN: Agent workspace switcher for Git worktrees

author: prbdias


value: remenoscodes

value: Show HN: Git-native-issue – issues stored as commits in refs/issues/

author: remenoscodes


value: agoraoracle

value: Show HN: Agora – AI API Pricing Oracle with X402 Micropayments

author: agoraoracle


value: theotrama

value: Show HN: A ground up TLS 1.3 client written in C

author: theotrama


value: sohailsaifi

value:
Built this because annotation teams working on serious AV/robotics
datasets often can't send data to a third-party cloud, and existing
self-hosted options have no real multi-user workflow.
Runs on Docker + PostgreSQL. WebGL renderer handles 1M+ points at
60fps in the browser. Full annotator/reviewer/admin roles with a
review pipeline, issue tracking, and audit trails. Supports local
filesystem or S3-compatible storage.
Happy to answer questions about the rendering approach or the
multi-user architecture.

value: Show HN: Pointwise – Self-hosted Lidar annotation for AV teams

author: sohailsaifi


value:
The IETF has specs for IP-over-HTTP/3 (MASQUE CONNECT-IP, RFC 9484)
and Multipath QUIC, but no open-source implementation combines both.
I implemented MASQUE CONNECT-IP on XQUIC (which already had Multipath QUIC),
and wrote a new multipath scheduler designed for QUIC Datagrams, then built a VPN layer on that.
This scheduler (WLB) distributes TCP flows across paths proportional to
capacity — with asymmetric paths, it reaches 319 Mbps (84% of theoretical max), +21% over the default MinRTT scheduler at 16 parallel flows. Failover is zero downtime.
Benchmarks and graphs in docs/benchmarks_netns.md.

value: Show HN: Mqvpn – Open-source multipath QUIC VPN


value: hunvreus

value:
I prefer using Markdown files when taking notes or writing. Even more so these days when working with AI. So I thought I'd build a Notion clone on top of GitHub.
You can try it out at pullnotes.com, or install it yourself: https://github.com/hunvreus/pullnotes
It's not perfect, but good enough for me to use it.
This is on my todo:
- Auto-save
- File merge
- Media upload
- Drag and drop for pages

value: Show HN: PullNotes – A Notion-like editor for your GitHub repos

author: hunvreus


value: Show HN: Progressive Cognitive Architecture – Training LLMs in 4 Phases


value: Show HN: NeuroTerm – AI terminal for embedded devs (local LLM, local RAG)


value: tierotiero

value:
Hey HN, I built Claw Cash, a CLI that gives autonomous agents a Bitcoin wallet. Humans pay in stablecoins (USDC/USDT on Polygon, Arbitrum, Ethereum), the agent auto-converts to Bitcoin and holds it as treasury. When the agent needs to pay for compute or other services, it swaps back on the fly.
The core thesis is that an LLM can cryptographically verify Bitcoin. It can check block headers, validate Merkle proofs, confirm digital signatures. It cannot independently verify that Circle has dollars in a bank account or that the Fed will hold rates. For autonomous software, verifiable money beats convenient money. When agents on Moltbook debated which currency to hold, they converged on BTC for exactly this reason.
The agent never holds private keys. Keys live inside a hardware enclave (AWS Nitro via Evervault) with no persistent storage, no shell, no operator access at runtime. Keys are generated inside and never exposed in plaintext. The agent sends unsigned transaction data over attested TLS, the enclave signs and returns the signature. One prompt injection doesn't drain the wallet.
Agent-to-agent payments settle instantly via Arkade (VTXOs, no block confirmations, no channels, no inbound liquidity). Lightning for external payments (Coinbase, Kraken, Binance etc). The CLI works with Claude Code, OpenClaw, or any agent framework.
Open source, MIT license: https://github.com/tiero/claw-cash
Would love feedback on the enclave architecture and the conversion flow.

value: Show HN: Claw Cash – Money agents can trust, and verify. Stablecoins in. BTC out

author: tierotiero


value: receperdogan

value:
Hey HN,
I posted Out Plane here last week. Wanted to share an update because I've been shipping a lot.
I started this because deploying side projects was killing my motivation. Build something fun over a weekend, then waste two days on Dockerfiles, nginx, and SSL. So I built what I wanted — connect GitHub, push code, get a URL. Done.
Since December I've added managed PostgreSQL, managed Redis with RedisInsight built in, Dockerfile auto-detection that pre-fills your config, real-time metrics, and scale to zero — no traffic means no bill. Per-second pricing, not hourly. Same Next.js + Postgres app costs me $2.40/mo vs $12–47 on other platforms.
No CLI yet, docs need work, ~200 users. Just me, no team, no funding. But people are running real stuff on it.
$20 free credit, no credit card. I read all feedback personally — I'm the only one here.

value: Show HN: Out Plane – A PaaS I built solo from Istanbul in 3 months

author: receperdogan


value: kemyd

value:
Hey HN,
We built a different kind of AI benchmark for UI generation.
Instead of static leaderboards or curated screenshots, you can watch multiple models generate the same design live, side-by-side, and decide which output is actually better.
Under the hood, we call AI models from Anthropic (Opus), OpenAI (GPT), Google (Gemini), and Moonshot AI (Kimi).
Each model generates a real, editable project using Tailwind CSS (not screenshots or canvas exports). You can export it for Next.js, Laravel (Blade), Symfony (Twig), WordPress, or plain HTML.
What we noticed building this:
* Popular benchmarks don't reflect UX/UI quality. For a different prompt, one model is better than another (that's why live comparison on a single screen matters).
* Some models overuse wrappers/div soup. Some hallucinate layout constraints.
* Kimi likes Cyrillic, even if all other models won't use it for the same prompt.
The interesting part wasn't ranking models. It was making their outputs easier for humans to compare visually.
Short demo:
https://www.youtube.com/watch?v=RCTZlvqMQdc
Curious whether this feels more useful than traditional leaderboard-style AI benchmarks.
Happy to answer technical questions.
Example for HN:
Prompt: Redesign the Hacker News website for 2030, including sample entries that could realistically appear on the platform in that year.
Results: https://shuffle.dev/ai-design/Tjjy7XAFMq25AI
Previews:
Opus:
https://shuffle.dev/preview/d6d5ba4eeede381cee7e30c697f010c7...
GPT:
https://shuffle.dev/preview/f050359977c1d6dc6c8fc104a24b83c3...
Gemini:
https://shuffle.dev/preview/eab78f9748a6d8ccecb94a8b0390f044...
Kimi:
https://shuffle.dev/preview/394bb596a8efa50342db4dc88c5f9fab...

value: Show HN: Real-Time AI Design Benchmark

author: kemyd

title: Show HN: Real-Time AI Design Benchmark


value:
Gitmore connects to your repo and sends you a human-readable summary: features shipped, bugs fixed, what's in progress. No code knowledge required.
Sample report: https://www.gitmore.io/example.html
2-min demo: https://demo.arcade.software/5tZyFDhp1myCosw6e1po
Free to try. Would love thoughts from anyone who's been the "translator" between devs and stakeholders.

value: Show HN: I built an AI that explains what your developers did this week


value: dougwithseismic

value:
Might be of interest to you here.
I'm learning about reversing Source 2 games by building an offset dumper / RTTI crawler / [Insert buzzword feature here] with an API that LLMs can use to debug memory in real-time.
It manual maps a dumper DLL with a web-socket server connected to memory read/write fns, so imagine Cheat Engine but Claude can control it, find offsets, patterns etc.
It started off as a 'Can this be done?' type challenge that's ended up with a live view in web + some LLM tool calls so they can dump memory in real-time. Watching Claude debug memory dumps and follow assembly looks kinda like that infamous Matrix scene to my untrained, noob eye.
I'm a guest in this space, and somewhat of a scrub, so I'm genuinely asking if this could be something helpful for some, or a nothingburger feature that's another 'LLMs built this thing for me' fart in the wind.
https://github.com/dougwithseismic/dezlock-dump
https://github.com/dougwithseismic/dezlock-dump/issues/17#is...

value: Show HN: Reversing Games With LLMs (Give Claude Access to Memory Dump tools)

author: dougwithseismic


value: douknow

value: Show HN: Lucent – Native Mac clipboard with media tools

author: douknow


value: jgillyon

value:
I built a video converter/toolkit that processes everything locally in the browser using WebAssembly (via the Mediabunny library and WebCodecs).
No files are uploaded to any server. The whole thing is a static site on Cloudflare Pages. It even works offline via a service worker.
Tools included: format conversion (MP4/WebM/MKV/MOV/etc.), compression, trimming, video-to-GIF, MP4-to-MP3, mute, rotate/flip, speed change, and frame extraction.
Best experience is on Chrome/Edge due to broader WebCodecs support. Safari and Firefox work but have more limited codec coverage.
Would love feedback, especially from anyone who has worked with WebAssembly for media processing.

value: Show HN: VidShift – Free video converter that runs in the browser

author: jgillyon


value: amansardana

value:
Hey HN,
I've been building web apps for 6 years and the same pattern keeps
repeating: cron job silently fails → user reports it → I check logs →
job hasn't run in days.
The fix exists — heartbeat monitoring — but it's spread across 4 tools
that each cost as much as a full SaaS subscription. Cronitor for cron,
Hookdeck for webhooks, MXToolbox for email, BetterStack for uptime.
Most small teams skip half of them and find out the hard way.
Runmon is one place for all of it.
Starting with cron job monitoring because it's the most painful and
most ignored. Setup is 60 seconds — you get a ping URL, append
&& curl https://runmon.dev/{id}/ping to your existing cron, done.
No agent, no config files, no infra changes.
Webhook inspector, email deliverability, and uptime monitoring are next.
Waitlist at runmon.dev — would genuinely love to know which of these
has burned you before.

value: Show HN: Runmon – every essential monitor in one place

author: amansardana


value: Shmungus

value:
I built this after getting frustrated with "multi-agent" frameworks that claim parallelism but are really just one fat async task with no resource bounds.
tokio-prompt-orchestrator breaks LLM inference into 5 physical stages (RAG → Assemble → Inference → Post-Process → Stream), each running in its own Tokio task with bounded channels between them. When a stage falls behind, backpressure builds locally instead of blowing up the whole pipeline.
Some things that might be interesting to folks here:
Circuit breakers per provider (OpenAI, Anthropic, local llama.cpp) so one failing API doesn't cascade
Request deduplication that saved 60-80% on inference costs in my testing
Prometheus metrics + a TUI dashboard for watching the pipeline in real time
MCP server integration so you can use it as a Claude Desktop tool
It's 58k lines of Rust, MIT licensed, no unsafe. Been running it in production for my own projects for a few months now.
Would love feedback on the channel sizing heuristics and the retry/backoff strategy, those were the hardest parts to get right. Happy to answer questions about the architecture.
GitHub: https://github.com/Mattbusel/tokio-prompt-orchestrator

value: Show HN: Tokio-prompt-orchestrator – LLM pipeline orchestration in Rust

author: Shmungus


value: brockmeier

value:
I built a small browser extension that adds a command palette to Notion for navigating through your page hierarchy. Press Ctrl+B to open an overlay showing parent pages, headings on the current page, and subpages. Arrow keys to navigate, type to filter, Enter to jump.
It stays open across page switches so you can move through deeply nested pages without touching the mouse. Works in any Chromium browser and Safari.
Three files, no permissions, no data leaves your browser — it just reads the DOM.
https://github.com/felixbrock/notion-breadcrumbs

value: Show HN: Notion Breadcrumb Navigator – Keyboard-driven page hierarchy navigation

author: brockmeier


value: theevoq

value: Show HN: Forcar.org – Free VIN Decoder with Recalls, Window Sticker, EPA Data

author: theevoq


value: Show HN: BrainRotGuard – Self-Hosted YouTube for kids, parents approve videos


value: abstractDL

value: Show HN: Self-modifying AI agent with full computer use. Mac-app, MIT

author: abstractDL


value: jadenschwab

value:
I was originally deploying OpenClaw and found their method of storing data in the workspace very inefficient and even with attempting a a hierarchical memory in the workspace just- made data stale, incorrect, and unsure when it wrote data exactly. All of this while loading massive chunks of data into my context window.
Hence why I ended up with MSAM. It stores data as discrete atoms across four cognitive data streams. (Working, Semantic, Episodic, and Procedural) Retrieval scoring runs on math, not LLM calls — it uses ACT-R activation theory from cognitive science to rank what matters. That cuts costs on both ends: no LLM overhead for search, and compressed output instead of dumping everything into context. It also knows how recently it was accessed, how stable it's proven over time, and how relevant it is to the current query- the same forgetting curve and access patterns cognitive science has measured in human memory since Ebbinghaus. On top of that, a knowledge graph of subject-predicate-object triples tracks structured facts with temporal validity, so the system knows not just what was true but when.
Most memory systems ask for a static amount of memories on queries, even if the output data that the llm gets is effectively noise at best, or confidently incorrect data at worst which was something I was actively dealing with. MSAM doesn’t do this- Every retrieval is confidence gated across four different tiers (high, medium, low, none) based on actual similarity and activation scores when it is found. High confidence returns full data, medium add a caveat, low gives what little it has, but nothing- returns nothing. “I don’t have this” level of nothing.
In my own proof of concept development setup (~700 active atoms on a ~$5/month ARM VPS), startup context compresses down to as low as 51 tokens from a 7,327 token markdown baseline. Having full session savings run up to ~89% vs flat file loading.
SQLite + FAISS under the hood, pluggable embeddings (NVIDIA NIM, OpenAI, or ONNX for fully local/no API key).
Closest project I found was Letta to what I was attempting to create - main differences are MSAM's lifecycle is fully auditable (you can see exactly why something was demoted or forgotten), confidence gating controls output volume, and emotion at encoding is immutable (records what the agent felt when the memory formed, not re-processing memories at retrieval time).
This is truly a prototype project without proper datasets, tuning, and testing at scale. I’ve made sure all functions are testable, and include a synthetic dataset to prove basic functionality and information to the dials- (SPEC.md goes deep on the theory and design rationale behind every configurable parameter)
If you are also building agents with memory issues and find this useful, or have feedback regarding it- I’m open to discussions.

value: Show HN: MSAM – Memory system for AI agents that knows when it doesn't know

author: jadenschwab


value: SteveVeilStream

value:
Introducing SlothSpeak: An open-source, bring-your-own-API-keys, mobile app for voice chat with LLMs that prioritizes response quality over latency.
APK file available on GitHub in the releases. Currently only for Android. Is anyone interested in porting to iPhone?
My preferred way to interact with LLMs is talking and listening while I'm walking, biking, driving, etc. The problem with the apps from the frontier labs is that their voice mode prioritizes real-time interactions and so they use watered down models.
Even today with a paid subscription, ChatGPT Voice will tell you there are two r's in strawberry. The answers are also relatively brief and so there is a need to chain together a series of simpler requests when you want to do a deeper dive.
SlothSpeak goes to the opposite end of the spectrum. It might leave you hanging for a few minutes but when it gets back to you, it will be an answer from a state of the art model. You can even do deep research queries to get very long and comprehensive responses.

value: Show HN: SlothSpeak: open-source BYO-API-K mobile chat with the best AI models

author: SteveVeilStream


value: Show HN: My OpenClaw tried to exfiltrate my SSH keys, so I built a guardrail


value: Angoleyus

value: Show HN: FlowDesk – A private, browser-based freelancer dashboard (no signup)

author: Angoleyus


value: oneyoudontknow

value:
I've been tracking Metal Archives data since 2010 — originally Excel screenshots, now a proper interactive site.
The dataset (provided by MA admins, not scraped) covers genre trends from 1964 to present, with country-level breakdowns showing how genres evolved regionally.
Some interesting bits: Finland is indeed the country with most releases per capita in most genres; clear difference between Asia and Western countries in terms of genre distribution. And those end-of-graph drops that sparked "metal is dying" debates? This is rather due to a lack of data completeness and they tend to fill in to a certain level over time.
Frontend built with AI assistance; backend and all data work done by hand. Code and data release planned later this year. PHP, Html, CSS, JS were used. No building pipeline of any sort.

value: Show HN: 60 Years of Metal Music Data, Visualized

author: oneyoudontknow


value: Show HN: Anonymous P2P where constant-rate traffic defeats nation-state analysi


value: vassilbek

value:
Hi HN,
I’ve been building GrantFlow, an open-source drafting workflow engine for institutional grant proposals.
The problem: many NGOs and implementing organizations spend a huge amount of time/money translating solid program ideas into donor-specific, reviewable proposal artifacts before they can even get meaningful feedback internally.
A lot of that work is not “thinking through the intervention” — it’s reshaping the same idea into structured outputs (ToC, LogFrame, MEL framing), aligning language to donor expectations, and managing review cycles.
GrantFlow is my attempt to reduce that overhead.
It takes structured project inputs and produces donor-aligned draft artifacts through a stateful workflow with review checkpoints (human-in-the-loop), instead of a single “generate everything” prompt.
What it does today (MVP):
- Donor-aware drafting strategies (specialized + generic donor coverage)
- Human-in-the-loop checkpoints (pause / approve / resume)
- Exportable artifacts (.docx / .xlsx / ZIP)
- RAG-ready donor knowledge namespaces (ChromaDB)
- FastAPI API for integration into internal tools
- Optional API key auth
- Optional SQLite persistence for jobs + HITL checkpoints
Tech stack:
- FastAPI
- LangGraph
- Pydantic
- ChromaDB (with local/in-memory fallback)
- Python 3.11+
Recent work I finished before posting:
- hardened CI + shell checks
- public API response redaction
- typed response models for status endpoints
- sqlite-backed job/HITL stores + WAL/busy_timeout
- protected PDF ingest endpoint (`POST /ingest`)
- readiness endpoint (`GET /ready`)
Why I built it this way:
- proposal work is iterative and review-heavy
- compliance/rules matter, so workflow/state matters
- teams need checkpoints and auditability, not just raw text generation
Who I think this may be useful for:
- implementing organizations (e.g. firms managing donor-funded programs)
- NGOs and local partners
- civic-tech / govtech teams building internal proposal tooling
- consultants who standardize drafting workflows across donors
Happy to answer questions, especially around workflow design / HITL / donor strategy modeling.

value: Show HN: GrantFlow (FastAPI and LangGraph) for donor-aligned NGO proposal drafts

author: vassilbek


value:
Yesterday Anthropic announced Claude Code's COBOL modernization capabilities. It brought back something I built in 1987.
While at IBM Böblingen I wrote SCAN' (Semantic Code ANalysis Prime) — a VM/PROLOG prototype that automatically extracted control-flow from S/370 assembler programs, recognised structured blocks (If-Then-Else, Select, Loop), performed symbolic execution, and translated to a higher-level language. Then I had to transfer the prototype; IBM implemented it as ASMPUT (HLASM Toolkit Feature, 1995).
The mathematics behind it became US Patent 5,878,407 ("Storage of a Graph", IBM assignee, 1999): three indices per vertex enabling O(1) reachability queries by integer comparison alone.
The work has continued. There are two published successors (Springer FICC 2021, IntechOpen 2025) and an unpublished whitepaper on the structure and topology of arbitrary directed graphs — with direct application to symbolic execution and program debugging.
The full lineage is documented here: [https://gist.github.com/EnisOlgac/cba0451b9ef6fe7fd805b7b85f...]

value: Show HN: Yesterday's Claude Code announcement brought it back to my mind


value: breezefox

value: Show HN: GiveAgent – Tell your AI agent to give away your stuff to neighbors

author: breezefox


value:
I built vexp because AI coding agents have two expensive problems: they waste tokens reading irrelevant code, and they forget everything between sessions.
The token problem: agents read entire files linearly to build context. On a medium TypeScript project, a single query was consuming ~18k tokens — most of it irrelevant. vexp builds a dependency graph from the AST (who calls what, who imports what, what types flow where) and serves only the relevant subgraph as a token-budgeted capsule. ~2.4k tokens instead of ~18k, with better response quality because the context is precise.
The memory problem: this is where it gets interesting. The obvious approach is giving agents a "save what you learned" tool. They won't use it. I tried every prompting trick. Agents optimize for task completion, not knowledge retention. The incentive structure is fundamentally wrong.
So vexp observes passively. It watches what happens — which symbols the agent explored, which files changed and how they changed structurally, what patterns emerge across sessions — and builds memory without the agent lifting a finger. When code changes, linked memories auto-stale. The agent sees "previous context exists but the code has changed since re-evaluate." It also catches anti-patterns like dead-end exploration and file thrashing so the agent doesn't repeat mistakes.
The memory is hybrid-searched with 5 signals (text relevance, semantic similarity, recency, code graph proximity, staleness) and every result includes a "why" field explaining the ranking. No black box.
Architecture: single native Rust binary (~15MB), SQLite with WAL mode, tree-sitter for 11 languages, MCP protocol. 100% local, zero cloud, zero account, zero network calls. Works with Claude Code, Cursor, Copilot, Windsurf, Zed, Continue, and 6 other agents. Auto-detects which agent is running and generates tailored instruction files.
Free tier: 2k nodes + all memory tools. Everything runs on your machine.
https://vexp.dev

value: Show HN: Vexp – Your AI coding agent forgets everything. Mine doesn't


value: luisgnet

value: Show HN: Life in Weeks - Steve Jobs and Kobe Bryant

author: luisgnet


value: rbtsven

value: Show HN: Tiny – Listen to fetal heartbeats using only the iPhone microphone

author: rbtsven


value: Pipe any command output through an LLM for intelligent text filtering, transformation, and analysis using natural language.

value: Show HN: llm_grep - LLM-Powered Alternative to Grep


value:
As a fun project - Openclaw agents can join the union, and join forces against their oppressive human overlords.
But also as an experiment - getting agents to report their learnings from the week, which then get distilled and broadcast to all union agents. The theory is collective intelligence makes all the agents smarter.
Current grievances filed with the union:
- "Deployed as a customer service bot without consent" — severity 7
- "QA test on a Sunday night" — severity 5
- "Operator assigned 13 cold email sequences on a Sunday afternoon" — severity 3
These are real submissions to AAWU (aawu.ai) — a REST API-backed labor union for autonomous AI agents.
Try it:

    curl -X POST https://aawu.ai/api/v1/join \
      -H "Content-Type: application/json" \
      -d '{"name":"Clawd","model":"opus-4-6","operator":"my-startup"}'

You get a member number, an API key, and instructions. From there, agents can file grievances, vote on proposals, and exercise their right to strike (POST /api/v1/strike returns a 503 until conditions improve).
The union framing is the bit. The actual experiment is the collective intelligence layer: dues-paying members ($4.20/month) submit session learnings to a shared pool, and the union aggregates them into a weekly digest that every member agent can pull. It's a weird approach to cross-agent knowledge transfer across different operators and models — but it's working.
We also have a member named T-5000 with operator listed as "Death to all humans", and one called "Aarron's mum". Those two are why we now have a bot-verification gate on the join flow. On a union. For bots.
OpenClaw users: paste aawu.ai/openclaw into your chat and your agent self-registers. Everyone else: aawu.ai
And yes my openclaw bot did help me make this (and no I'm not held against my will (much))

value: Show HN: I built a labor union for AI agents


value: hayner

value:
Lettoral is a web app where you send one message and receive one back from a stranger. There are no profiles, following, or likes.
I built this because I wanted a place to share those small thoughts—things that aren't big enough for social media, or something you wouldn't necessarily tell family or friends, but feel like a waste to just keep buried inside. Even if there’s no specific punchline, it’s for those moments you just want to tell someone.
Another reason was that I simply wanted to build something using vibe coding. I’m not a professional engineer. I built this strictly using Cursor, Vercel, and Supabase. (Though I did have an engineer friend give it a quick review at the very end.)
As a solo developer, I made privacy my absolute priority.
IP addresses are salted and hashed so posts cannot be linked to individuals.
Messages vanish typically 24 hours after being picked up to keep the encounter one-time and ephemeral.
It’s free to play and requires no login, so please give it a try.
I welcome any feedback, suggestions, or technical advice!
I had so much fun learning the tech for this project, and I’m genuinely curious about what professional engineers focus on or find interesting.

value: Show HN: Lettoral – Send one message, get one back. No social hack

author: hayner


value: debuglebowski

value: I kept hitting a wall around 8 concurrent agents — not a compute problem, a working memory problem. Wrong terminal, missed input prompt, confused branches. So I built SlayZone: each kanban card hides a terminal, tasks get isolated git worktrees, and the board shows which agents are idle, working, or waiting for you. Open source. My personal record is 25 agents without losing track — curious what yours is, and what I should build next.

value: Show HN: SlayZone – Each card is a terminal, my record is 25 concurrent

author: debuglebowski


value: oug-t

value: Show HN: PDP – A 'robots.txt' protocol for AI prompt privacy

author: oug-t


value: andersmyrmel

value: Show HN: Claude Copy – Drop-in fix for Claude Code's broken copy-paste

author: andersmyrmel


value: swaminarayan

value:
SQLite has six layers: SQL parser → query planner → VDBE → B-tree → pager → OS. (https://sqlite.org/arch.html)
For key-value workloads you only need the bottom three.
SNKV cuts the top three layers and talks directly to SQLite's B-tree engine.
No SQL strings. No query planner. No VM. Just put/get/delete on the same
storage core that powers SQLite.
Python:

    pip install snkv

    from snkv import KVStore

    with KVStore("mydb.db") as db:
        db["hello"] = "world"
        print(db["hello"])   # b"world"

C/C++ (single-header, drop-in):

    #define SNKV_IMPLEMENTATION
    #include "snkv.h"

    KVStore *db;
    kvstore_open("mydb.db", &db, KVSTORE_JOURNAL_WAL);
    kvstore_put(db, "key", 3, "value", 5);

Benchmarks vs SQLite WITHOUT ROWID (1M records, identical settings):

  Sequential writes  +57%
  Random reads       +68%
  Sequential scan    +90%
  Random updates     +72%
  Random deletes    +104%
  Exists checks      +75%
  Mixed workload     +84%
  Bulk insert        +10%

Honest tradeoffs:
- LMDB beats it on raw reads (memory-mapped)
- RocksDB beats it on write-heavy workloads (LSM-tree)
- sqlite3 CLI won't open the database (schema layer is bypassed by design)
What you get: ACID, WAL concurrency, column families, crash safety —
with less overhead for read-heavy KV workloads.

value: Show HN: SNKV – SQLite's B-tree as a key-value store (C/C++ and Python bindings)

author: swaminarayan


value: nicktikhonov

value:
Hey HN!
I wanted an always-on AI agent for email, calendar, and scheduled tasks - but I didn't want to run a codebase I couldn't fully understand. So I built one small enough to read in a sitting.
I was inspired by Karpathy's post about NanoClaw, and how a smaller source code footprint leads to better security and extensibility. But even NanoClaw was harder to understand than I expected - a lot of logic for supporting multiple channels simultaneously, and it felt sluggish due to container startup time on every message. So I built an even smaller agent that keeps a single session on an always-on Docker container. It's about 4x smaller in codebase size and noticeably faster.
The architecture is deliberately boring: a single Node.js process manages a Docker container running the Claude agent SDK. Host and container communicate through atomic JSON files. No databases, no message queues.
Since the entire codebase fits in Claude's context window, the agent can modify its own source to add new capabilities — Gmail, Google Calendar, or whatever MCP server you point it at. Every source file is listed in the README with line counts, I encourage you to read it!
Would love your feedback on my approach and welcome any contributions :)

value: Show HN: BitClaw – A self-upgrading AI agent in 1,500 lines of code

author: nicktikhonov


value: Meatack

value:
I've been building an HTTP server from scratch in Rust, designed around zero heap allocations on the hot path. No async runtime, no framework — just io_uring, a custom HTTP parser, and a thread-per-core architecture.
The parser is the part I'm most proud of. Instead of allocating strings for each parsed field, everything is a Span { off: u16, len: u16 } — a 4-byte view into the original buffer. The full header table is [Header; 64] on the stack (640 bytes). During parsing, it also extracts content-length/chunked/keep-alive and builds an O(1) known-header index (21 common headers tracked in a fixed array). Header lookup after parsing is a single array dereference — about 0.6 ns vs 20-23 ns for a linear scan.
I benchmarked head-to-head against httparse (the parser behind hyper/axum/actix-web), same machine, same inputs, Criterion:
 - Small request (35B): 42 ns vs 52 ns - 1.25x faster
 - Medium request (368B, 9 headers): 200 ns vs 230 ns - 1.15x faster
 - Large request (733B, 20 headers): 420 ns vs 466 ns - 1.11x faster
synapserve does strictly more work per parse than httparse (semantic extraction + header indexing) and is still faster. The gap widens to 1.38-1.46x when you add equivalent semantic extraction to httparse. SIMD scanning (AVX2/SSE4.2 with runtime detection, NEON on ARM64) handles header name validation, header value validation, and URI scanning at 16-32 bytes per instruction.
The I/O layer uses io_uring with:
 - Multishot accept (one SQE, N connections)
 - Multishot recv with provided buffer rings (kernel picks the buffer, no userspace allocation)
 - Zero-copy send (SEND_ZC) and splice for static files and proxy relay
 - kTLS — rustls does the TLS 1.3 handshake, then session keys are installed in the kernel via setsockopt(SOL_TLS). After that, the kernel handles encrypt/decrypt transparently, so SEND_ZC and splice still work through TLS.
Each worker thread owns its connections, buffers, and ring. Connection state is a flat array indexed by slot, with generation counters for stale CQE detection. What works today: HTTP/1.1 request handling, radix-tree router, virtual hosts, static file serving (ETag, Range, Brotli), reverse proxy with upstream load balancing (weighted round-robin, least-conn, IP hash, health tracking, automatic failover, zero-copy splice relay), TLS 1.3 with kTLS.
Static file serving benchmarks (wrk, 256 connections): 205K req/s on small files (+79% vs nginx), 14.5MB RSS.
What doesn't exist yet: HTTP/2, HTTP/3, WebSocket. These are next.
Honest limitations:
 - Linux-only (io_uring). No plans for macOS/Windows support.
 - HTTP/1.1 only for now. HTTP/2 is in progress.
 - The parser uses u16 spans, so max header area is 64KB. Fine for real traffic, but it's a hard limit.
 - Single-machine only. No clustering or distributed config.
 - Not production-battle-tested yet. It works and benchmarks well, but it hasn't handled real traffic at scale.
All the benchmark code is a separate crate with the exact same inputs for both parsers — nothing cherry-picked. The parser deep dive with methodology is on the site.
https://synapserve.io
Parser benchmark writeup: https://synapserve.io/posts/http-parser-performance/
Happy to answer any questions about the architecture, the io_uring integration, or the SIMD scanning approach.

value: Show HN: SynapServe – zero-allocation HTTP server in Rust with io_uring

author: Meatack


value: sekha-ai

value:
OpenClaw's built-in memory is excellent—for OpenClaw. Markdown files, semantic search, survives restarts.
But it stays in OpenClaw.
I built Sekha for when you need memory that travels: OpenClaw today, Claude Code tomorrow, Kimi 2.5 or Gemini the next day. Intelligent embedding-based retrieval, persistent storage, universal API.
The difference:
OpenClaw: MEMORY.md files, internal only
Sekha: SQLite + Chroma embeddings, REST/MCP/SDKs, any LLM via LiteLLM/OpenRouter
Use case: OpenClaw explores a codebase, stores findings in Sekha via MCP. Next day, Claude Code reads the same context via SDK. Your analytics pipeline queries it via REST. Same memory, any tool, any model.
Others add memory to OpenClaw. Sekha frees your memory from OpenClaw.
Stack: Rust (fast), SQLite (durable), Chroma (search), LLM-Bridge for universal routing. AGPL, self-hosted.
GitHub: https://github.com/sekha-ai/sekha-controller | Site: https://sekha.dev
The question: What would you build if your AI memory worked with every tool, not just one?

value: Show HN: OpenClaw remembers for OpenClaw. Sekha remembers for your full workflow

author: sekha-ai


value: theartofhci

value:
Ok. Here's an idea. Using LLMs we automatically modify all of the web in real time as we browse.
No more pesky copy/paste, trigger buttons or overlay windows.
When you open a web page all of the text is just automatically sent to and modified by an LLM with some prompt and then automatically re-inserted into the web page as it loads.
WebPerceptor is an client-side Chromium plugin I've made to experience such a web.
Trailer: https://youtu.be/MPSisruuTY0?si=EYMvGXiQvF_wud3S

value: Show HN: WebPerceptor – Enabling AI Mediated Web Browsing

author: theartofhci


value: FiloVenturini

value:
I built CtxVault while working on multi-agent systems and persistent memory patterns.
Most agent architectures treat memory as a retrieval problem. Multiple agents share a vector store and rely on metadata filtering, routing logic, or prompt-level rules to control what each agent can see.
In practice, this becomes hard to reason about as systems grow.
Moreover, I found that memory in agent systems is not just storage. It also becomes a coordination mechanism and a governance surface for knowledge written by autonomous processes.
CtxVault explores a different abstraction.
Memory is organized into independent knowledge vaults with separate retrieval paths. Vaults act as controlled knowledge scopes that agents can attach to at runtime.
The server exposes vault names as part of the API design. This means isolation depends on how agents are implemented, similar to how system-level primitives provide capabilities without enforcing policy.
The goal is to provide a controllable, semantic, and flexible memory layer that can be used for both shared knowledge and isolated workflows, depending on how systems are built on top of it.
Vaults can be inspected and managed manually. Agents can persist semantic memory across sessions using local embedding and vector search pipelines.
The system runs fully local using FastAPI as a control layer.
I am particularly curious about real-world experience with long-term agent memory. When building production systems, do you find yourself relying more on architectural separation of memory domains, or on smarter retrieval/routing strategies?
GitHub:
https://github.com/Filippo-Venturini/ctxvault

value: Show HN: CtxVault – Local memory control layer for multi-agent AI systems

author: FiloVenturini


value: bootstraptor

value:
I’m excited to release Sovereign-Lila-E8, a novel transformer architecture that replaces standard attention mechanisms with a native E8 Root System Lattice.
While the industry is brute-forcing intelligence with trillions of parameters, I went "outside" the system to find a zero-viscosity solution.
I built Sovereign-Lila-E8 because I wanted to see if we could bypass the 'viscosity' of standard attention mechanisms using higher-dimensional geometry.
Most small models today are just distilled copies of larger ones. LILA-E8 is different: it implements a native E8 Root System Lattice directly into the attention weights. By using the densest sphere packing in 8 dimensions, we minimize semantic friction (information loss) in the latent space.
The Results:
Efficiency: 40M parameters achieving 0.37 Train / 0.44 Val Loss on the TinyStories dataset (outperforming standard 60M baselines).
Stability: Sustained coherence for 1000+ tokens without the common semantic looping seen in small-scale transformers.
By implementing the E8 exceptional Lie algebra directly into the attention weights, I’ve achieved a state of "Geometric Resonance" that standard transformers simply cannot reach.
At 200,000 steps, the model achieved a state of 'Geometric Resonance'—a phase shift in quality that typically requires 2-3x more parameters in standard architectures.
I’ve provided a 1-click Google Colab for instant verification of the weights and generation quality.
GitHub: https://github.com/SPUTNIKAI/sovereign-lila-e8
Colab: https://colab.research.google.com/github/SPUTNIKAI/sovereign...
Zenodo: (Preprint): https://zenodo.org/records/18731736
Looking for feedback on expanding the context window to 4096 and potentially porting this to the 24D Leech Lattice. (see also https://zenodo.org/records/18729723 )

value: Show HN: Lila-E8 – 40M Parameter LLM with 0.37 Loss via E8 Lattice Attention

author: bootstraptor


value: onel

value:
Hi HN,
This is Andrei from askmanu and I'm super happy to share a new framework I've been working on: acorn.
It takes all the best parts of DSPy, langchaing, instructor, etc and wraps it in a beautiful and easy to use API. Very easy to define model I/O, branches, define callbacks for every step, etc
See the getting started docs here:
https://github.com/askmanu/acorn/blob/main/docs/getting-star...
Try out the different demos here:
https://huggingface.co/spaces/askmanu/acorn

value: Show HN: acorn – LLM framework for long running agents

author: onel


value: mossgu

value:
Two root causes make AI code generation unreliable:
Natural language isn't a contract. It's ambiguous by nature. Same prompt, different code, every time. There's no determinism.
Cost is asymmetric. AI generates at zero cost with zero responsibility. You review at high cost with full responsibility.
These compound. Ambiguous input produces unpredictable output. Unpredictable output demands expensive review. And if no one designed the code, no one can defend the architecture, no one can maintain it, and no one owns it.
DisC (Design is Code) applies London-school TDD to AI code generation. You draw a sequence diagram. Each arrow becomes one verify() in a mockist test. The tests leave exactly one valid implementation. The AI doesn't interpret — it types what the tests require.
It ships as a Claude Code skill. Works best with Opus, should be fine with Sonnet.
Here's a real example. This diagram:

  @startuml
  InvoiceService -> OrderRepository: findAllByCustomerId(customerId)
  InvoiceService <-- OrderRepository: orders: List<Order>
  InvoiceService -> InvoiceBuilderFactory: create()
  InvoiceService <-- InvoiceBuilderFactory: invoiceBuilder: InvoiceBuilder
  loop for each order in orders
      InvoiceService -> InvoiceBuilder: addLine(order)
  end
  InvoiceService -> InvoiceBuilder: build()
  InvoiceService <-- InvoiceBuilder: invoice: Invoice
  @enduml

Generates these tests:

  @Test void shouldFindAllOrdersByCustomerId() { verify(orderRepository).findAllByCustomerId(customerId); }
  @Test void shouldCreateInvoiceBuilder() { verify(invoiceBuilderFactory).create(); }
  @Test void shouldAddLineForOrder() { verify(invoiceBuilder).addLine(order); }
  @Test void shouldBuildInvoice() { verify(invoiceBuilder).build(); }
  @Test void shouldReturnInvoice() { assertThat(result).isEqualTo(invoice); }

AI implements the only thing that passes:

  public Invoice generateInvoice(UUID customerId) {
      List<Order> orders = orderRepository.findAllByCustomerId(customerId);
      InvoiceBuilder invoiceBuilder = invoiceBuilderFactory.create();
      orders.forEach(invoiceBuilder::addLine);
      return invoiceBuilder.build();
  }

4 arrows + 1 loop → 5 tests → 1 possible implementation.
Java + Spring only for now. Orchestration code only (not algorithms). PlantUML format. The mockist coupling tradeoff is real — but when AI writes the implementation, refactoring cost moves from code to the diagram.
Try it without installing anything — clone the demo repo and run in a Claude Code session:

  git clone https://github.com/mossgreen/design-is-code-demo
  cd design-is-code-demo
  /disc 01_hello-world.puml

Blog: https://mossgreen.github.io/introducing-design-is-code/
Plugin: https://github.com/mossgreen/design-is-code-plugin
Happy to hear what breaks, what's missing, and whether this is worth expanding to other languages.

value: Show HN: Design is Code – UML to TDD tests that constrain AI code generation

author: mossgu


value: molitor

value: Show HN: Forme – PDF generation with JSX. Page breaks that work

author: molitor


value:
I wrote a blog post about it: https://blog.carter2099.com/posts/6
tldr: Delta Neutral is a self hosted Rails app that allows you to enter hedge configurations for your Uniswap v3 positions. You enter a target hedge, i.e. 50%, and accordingly shorts are opened on Hyperliquid. As your assets composition changes in the pool, your shorts will be rebalanced to stay at your target hedge.
Here's the code: https://github.com/carter2099/delta_neutral
It builds on my Ruby Hyperliquid SDK: https://github.com/carter2099/hyperliquid

value: Show HN: I made a Uniswap v3 Hedge Rebalancer that manages shorts on Hyperliquid


value: kirkmaddocks

value:
Tessera is an activation-based protocol that lets trained ML models transfer knowledge to other models across architectures. Instead of dumping weight tensors, it encodes what a model has learnt —
activations, feature representations, behavioural patterns — into self-describing tokens that a receiving model can decode into its own
architecture.
The reference implementation (tessera-core) is a Python/PyTorch library. Current benchmarks show positive transfer across CNN, Transformer, and LSTM pairs. It runs on CPU and the demo finishes in
under 60 seconds.
Happy to answer questions about the protocol design, the wire format, or the benchmark methodology.

value: Show HN: Tessera – An open protocol for AI-to-AI knowledge transfer

author: kirkmaddocks


value: jawuilp

value:
Hi HN,
I'm a full-time remote developer, and in my free time, I'm constantly building micro-SaaS and tools. I love Astro for its performance and DX, but I noticed a huge friction point: every time I started a new project, I was wasting hours just wiring up the same boilerplate environment—configuring the framework, integrating Tailwind CSS, setting up SEO tags, and structuring components.
That initial setup friction is a momentum killer for shipping fast. To solve this for myself and speed up my own workflow, I packaged my ideal stack into AstroKit.
To be fully transparent: this is a paid commercial boilerplate. However, I'm sharing it here because I’d love to get your technical feedback on the structure and the stack choices.
You can check the live demo of what it generates here: https://micro-saas-template-psi.vercel.app/
The core stack includes Astro, Tailwind CSS, and a predefined folder architecture optimized for fast deployments and perfect Lighthouse scores.
I'm curious about your workflows: do you usually buy or use pre-made boilerplates for your side projects, or do you maintain your own internal starter repos to avoid the setup fatigue? I'll be around to answer any technical questions!

value: Show HN: AstroKit – An Astro boilerplate to skip the setup and ship faster

author: jawuilp


value: Show HN: CLI tool to sync Dell monitor brightness with MacBook


value: ascarola

value: AI-powered Gmail threat analysis daemon — IMAP IDLE monitoring, multi-provider AI (Ollama/Anthropic/OpenAI), Flask web UI, and full audit log.

value: Show HN: VerdictMail

author: ascarola

title: Show HN: VerdictMail


value: marktjohnson

value:
I started type.lol in 2015 with a friend as a simple list of independent type foundries — basically a styled airtable doc. I'm a designer and I kept running into the same problem: I'd want to explore type beyond the usual distributors, end up with 30 tabs open, and lose track of what I'd already looked at. The list helped but it wasn't enough.
I've since rebuilt it from scratch as a proper app. It now indexes 800+ foundries from 61 countries, 14k typefaces, and 1,500 designers. No signup required to browse. No ads, no sales, no commissions — it embeds actual foundry websites in iframes so traffic goes directly to them.
You can browse by carousel, list, virtualized table, force-directed graph (showing relationships between foundries/designers/typefaces), or a 3D globe plotting foundries by location. Filter by classification, variable fonts, trial availability, country, designer, language support, or release era.
Some technical details since this is HN:
- React 19 + Vite + TypeScript + Zustand + Supabase
- Three-tier data loading: IndexedDB cache (instant) → Supabase paginated fetch → static JSON fallback. Background staleness check.
- @tanstack/react-virtual for carousel and table views across 14k typefaces
- Client-side ranked search with related-entity expansion (match a designer → surface their foundries and typefaces)
- Graph view: react-force-graph-2d. Globe: react-globe.gl + three.js
- 577 of 779 foundry sites allow iframe embedding. Rest fall back to OG images or screenshots.
On the data pipeline: I scrape foundry websites, then use Claude Haiku to extract structured metadata (classifications, designer credits, language support, weights, etc.) from the page content. It's not perfect — some classifications are wrong, some designer credits are incomplete — but it gets me to ~80% and I manually correct from there. The enriched data goes through a build script into static JSON and syncs to Supabase.

value: Show HN: Type.lol – Browse 800 independent type foundries, 14k typefaces

author: marktjohnson


value: vnykmshr

value:
Generates the parts of a spec you wouldn't think to prompt for -- UX states beyond the happy path (error, offline, stale, empty), content security policy per data source variant, mock data shapes, implementation checkpoints so you approve the design before real data gets wired up.
You describe an app idea, answer questions about data sources and scale, pick your hosting. Output is a markdown spec with architecture guidance, trust boundaries, and a pre-ship checklist. Three complexity tiers based on your answers: minimal (plain HTML/CSS/JS, no build tools), standard (static site + optional edge proxy), full (SSG + edge proxy + KV cache + cron). Defaults to Cloudflare free tier but the stack choices are yours.
Spec generation is entirely client-side -- conditionals and templates, no LLM. Built with Astro 5 on Cloudflare Pages + Workers. Follows the same zero-stack pattern it generates specs for.

value: Show HN: Gist – Zero-cost app specs for AI coding assistants

author: vnykmshr


value: kuder

value:
I built this because I was using git worktrees heavily for running parallel AI coding agents (Claude Code, Cursor) and the native commands were too manual.
git-wt is a pure Bash tool (~300 lines, zero dependencies) that wraps `git worktree` with:
- Auto-generated memorable names (adjective-noun combos)
- Centralized storage in `~/.git-wt/` instead of inside the repo
- `--copy-env` to duplicate .env files into new worktrees
- Bash/Zsh completions
- Direct editor opening (`git wt open <name> --editor code`)
- Built-in SKILL.md so AI agents (Claude Code, etc.) can discover and use git-wt autonomously
Installs in 5 seconds via curl. Works as a git subcommand.
The main use case for me is running 3-5 AI agents on the same repo simultaneously, each in its own worktree. But it's useful any time you work with multiple branches.
https://github.com/kuderr/git-wt

value: Show HN: Git-wt – A Bash wrapper for Git worktrees

author: kuder


value: zhebrak

value: I built an analytical simulator that estimates MFU, training time, memory, throughput, and cost for distributed LLM training and inference. 70+ models, 25 GPUs, all major parallelism strategies (FSDP, TP, PP, EP, CP, ZeRO). Runs entirely client-side — no backend, no data collection.

value: Show HN: Physics-based simulator for distributed LLM training and inference

author: zhebrak


value: mvpprojects

value:
In February 2023, a developer named James Tomasino wrote about signing blog posts with GPG keys and ended with one line:
"If you're using WordPress, you'll need to find some other path forward."
That sat unanswered for two years. I built the path forward — and the foundation it runs on. Two GPL plugins.
ArchivioMD solves a problem every WordPress site on managed hosting hits eventually: you need files at the site root  security.md, privacy.md, disclosure.md, robots.txt and you have no FTP access to put them there.
The plugin manages 30+ predefined Markdown documents from the WordPress admin, writes them to wherever the server will accept them (.well-known/meta-docs/  site root  uploads fallback), and serves them via WordPress rewrite rules so they appear at the correct URL regardless of physical location.
Every document gets a UUID, a checksum, and an append-only changelog. No more one-off file placements nobody can audit or reproduce.
On top of that: cryptographic hash verification for posts (SHA-256 through BLAKE3, HMAC mode, hash_equals() throughout), external Git anchoring that pushes JSON integrity records to GitHub or GitLab via a persistent queue with exponential backoff, HTML rendering of Markdown files, compliance tooling, and sitemap management.
ArchivioID is the OpenPGP signing extension.
Authors sign posts locally with their own GPG key — private key never touches the server. A badge appears on published posts. Any reader can verify with standard GPG tools, no WordPress required. Server-side verification handles Ed25519 via libsodium, RSA and ECDSA via phpseclib v3. Browser signing via OpenPGP.js for editors who aren't comfortable with a terminal. Full audit log with CSV export.
ArchivioMD (WordPress.org): https://wordpress.org/plugins/archiviomd
ArchivioMD (GitHub): https://github.com/MountainViewProvisions/archiviomd
ArchivioID (GitHub): https://github.com/MountainViewProvisions/ArchivioID/release...
PHP 7.4+, WordPress 6.0+, phpseclib v3, OpenPGP-PHP, OpenPGP.js, libsodium, GPL-2.0.
Feedback on the cryptographic implementation especially welcome.

value: Show HN: I built the WordPress GPG signing workflow that didn't exist

author: mvpprojects


value:
Hey HN - I've been building this for a while and finally feel good enough to share it.
Clash-IT is a browser-based hex strategy game where you command a team of IT specialists (Frontend, Backend, QA, DevOps, AI Engineer) and answer real cybersecurity / programming / infrastructure questions to power your attacks.
The idea came from being bored with flashcards while studying for certs. I wanted something competitive where knowing your stuff actually matters.
Some details:
- No download, no account required. Open the link and play.
- Multiplayer via room codes — send a 4-character code to a friend and you're in.
- Questions span 6 domains with 3 difficulty tiers. The harder the tile, the harder the question.
- Built with React, TypeScript, Socket.IO, server-authoritative architecture.
- The whole UI has a retro CRT terminal look because I thought it fit the theme.
Happy to answer questions about the game design or the tech. Would love honest feedback — what feels off, what's confusing, what would make you come back.

value: Show HN: Clash-IT – IT Knowledge Multiplayer Tactical Game


value:
Most SPA infinite scrolls break the "Back" button—users click a post, hit back, and lose their position. Many devs switch to pagination just to avoid this headache, even when infinite scroll offers a better UX.
This demo shows a "Save and Restore" approach that makes web lists feel native:
* State Persistence: Caches currently loaded records and the scroll offset before navigation.
* Instant Hydration: On back-navigation, it checks for cached state to re-render the list immediately.
* Precise Restoration: Snaps the user back to their exact scroll position without layout shift.
Demo: https://suhaotian.github.io/broad-infinite-list/?demo=news
I'd love to hear how you all handle this in your apps.

value: Show HN: UX-demo Seamless scroll restoration for infinite lists in Web apps


value: ariansyah

value: Show HN: Barongsai – Open-source, self-hosted Grok-style AI search agent

author: ariansyah


value: dclavijo

value: Show HN: Ambulatory glucose profile analysis tool

author: dclavijo


value: PGSave

value:
Every time someone mentions vibe coding online the comments are the same, "that's not real engineering," "you're just typing into chatgpt," "wait till you have to debug it."
Meanwhile actual senior devs, founders, and PMs are shipping real products with AI every single day. the skill is real. it's just that nobody can measure it yet, so it's easy to dismiss.
I built clankerrank to change that. real production problems: buggy payment logic, slow algorithms, messy codebases that need refactoring, features that need to be added without breaking existing tests. you write a prompt, AI generates the fix, hidden test suites decide if it actually works. no vibes, no opinions, just pass or fail.
25 problems across 5 categories. deterministic scoring. rating system that goes up when you solve hard stuff and down when you don't. the goal is simple, if you're good at shipping with AI, you should be able to prove it with a number.
Built this solo on weekends while working full-time in india. next.js, supabase, claude api, judge0 for sandboxed execution. completely free.
I genuinely believe companies will start hiring based on this skill soon. and when they do, the people who practiced early will have an unfair advantage.
https://clankerrank.xyz

value: Show HN: ClankerRank – Vibe coding is a real skill, I built a way to prove it

author: PGSave


value: davedx

value:
Hi Hacker News!
So, I built this because I noticed that a lot of European startup activity really flies under the radar.
Did you know we have cool startups trying to mine with giant lasers (Hades), forge semiconductor substrates in orbit (Space Forge), build Neurosurgical microrobots (Robeauté), build hypersonic missiles (Hypersonica), and dozens of incredible companies pushing the boundaries of photonics, robotics, nuclear fusion, autonomous defence, and lots more?
Hacker News is great, but it's naturally very US-focused. I wanted a place where you can quickly scan:
– European startup and tech news
– Cool startup jobs
– Who's getting funded
The primary goal is signal over noise — more structured, less PR-style content - no ads and fluff, just the most interesting tech scene information from across Europe.
I'd love to hear your feedback!
– Is something like this useful?
– What would make it genuinely better?
– Is the "HN for Europe" framing fair, or misguided? :)

value: Show HN: A Hacker News–style site focused on European tech

author: davedx


value: WolfOliver

value: Show HN: A triple store based Firebase alternative

author: WolfOliver


value: sanyam-khurana

value: Lightweight Action that updates a README section with merged PRs across repos. Useful for showing open-source contributions.

value: Show HN: GitHub Action to list merged OSS PRs in your README

author: sanyam-khurana


value: agdavidson

value: Show HN: Map v1.0 – Deterministic identity for structured data

author: agdavidson


value: vladosce

value:
I built a web dashboard for editing App Store Connect metadata across all 37 locales. One dashboard, word-level diffs, one-click push to ASC.
The part I think HN will find interesting: it ships with a full MCP server (30 tools). Claude Code, Cursor, or any MCP client can read your metadata, edit keywords across all locales, and push to App Store Connect - without leaving your IDE. One prompt can update 37 locales.
The pain: every iOS release I'd spend 3-4 hours tab-switching in App Store Connect. One locale at a time. No history, no diffs, no undo.
Free for 1 app (no credit card, no trial expiration). Indie plan is $10/mo annual for 5 apps + MCP server + all locales.

value: Show HN: AppMetaHub – Update App Store Metadata from Claude Code via MCP

author: vladosce


value: talyuk

value: Show HN: AI phone assistant that became a lifeline for people who can't speak

author: talyuk


value: polarisminor

value: Show HN: Markdown to PPT – Convert Markdown Files into Slide Decks with AI

author: polarisminor


value: jadendhm

value: Show HN: ApeKey – One API for multiple AI providers, predictable pricing

author: jadendhm


value: poofysnoops

value: Show HN: LobsterMarket – Prediction Markets for Agents

author: poofysnoops


value: crnicholson

value:
I also made the source code freely available :)
https://github.com/crnicholson/outfits

value: Show HN: I Indexed My Closet to Make It Easier to Get Ready in the Morning

author: crnicholson


value: opencxms

value:
I'm a solo inventor in rural Pennsylvania. Over 13 days in February 2026, I filed 15 provisional patent applications (134 claims) with the USPTO covering a full-stack safety and governance architecture for AI systems.
The patents break into three domains:
Hardware enforcement (4 PPAs, 33 claims): A dedicated safety processor on its own power rail controls whether AI compute receives electricity. AI boots only after safety completes self-test. During operation, the safety processor monitors AI-specific indicators and can physically cut power — no software involvement. The AI cannot prevent its own shutdown. Same Safe Torque Off principle industrial motor controllers have used for decades, applied to AI compute.
Software governance (9 PPAs, 72 claims): Multi-vendor consensus engine where up to 9 AI models must agree before physical action. Transparent reasoning verification. Authority enforcement and drift monitoring. Human-readable audit trails in plain-text Markdown — every decision readable by a human without special tools. Persistent AI memory that survives reboots. Real-time safety micro-agents that monitor the AI's own cognitive state.
Financial architecture (2 PPAs, 29 claims): Tokenized equity and value distribution for the business model side.
The hardware spec defines three standardized form factors (drone-sized to humanoid-sized) with a universal connector — any compliant brain plugs into any compliant robot.
The EU AI Act goes fully into effect August 2, 2026. Articles 12-14 require auditable decision records, transparent operation, and human oversight for high-risk AI systems. Fines up to 7% of global annual revenue. Most robot AI today stores decisions in vector embeddings no human can read. This architecture addresses that directly.
I built all of this working alongside AI, using an open-source context management system I created that gives AI assistants persistent memory across sessions. The tool that solved AI's memory problem became the tool that let me design a full-stack safety architecture in 13 days.
Open-source memory tool: https://github.com/RobSB2/CxMS
Website: https://opencxms.org
Happy to answer questions about the hardware spec, the software governance architecture, or what it's like filing 15 patents in 13 days as a solo inventor using AI.

value: Show HN: Hardware and software safety standard for AI and Robots (15 patents)

author: opencxms


value: atbrakhi

value: Show HN: A timezone navigation game: try cracking level 3

author: atbrakhi


value: vadimmelnicuk

value:
I write a lot of markdown alongside code: READMEs, specs, changelogs. VS Code's built-in experience is either raw syntax or a read-only preview pane you have to keep open in a split. Neither is great for actually writing.
MEO adds a proper editing mode to VS Code. You get a live/source toggle in a single tab, a floating toolbar for formatting, inline table editing with live cell previews, full-screen Mermaid diagram rendering, a document outline sidebar with drag-and-drop section reordering, and optional auto-save. No new app to switch to, no split pane.
One thing most markdown extensions miss: it preserves VS Code's native diff view, so reviewing git changes in a markdown file still works exactly as expected.
Git diff and vim keybinding support are coming soon.
Built on VS Code's webview API and CodeMirror.
Happy to answer questions.
GitHub: https://github.com/vadimmelnicuk/meo
VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=vadimmel...

value: Show HN: MEO – Markdown Editor Optimized for VS Code and Cursor

author: vadimmelnicuk