value: Magnanten

value:
Hey HN, we’re Nico and Arseniy, co-founders of Superlog (https://superlog.sh). We're building a self-installing, self healing observability tool meant not to be opened. It has a wizard that daily sets up proper logging and an agent that investigates errors and opens PRs.
Super short demo: https://www.youtube.com/watch?v=xFhU9Mk247M.
In our earlier startups, we tried Sentry, Datadog, Grafana, Dash0, and nothing was good enough.  Proper telemetry and alerting still requires a ton of manual setup. We struggled with adding good logs, so debugging was tough, especially as codebases grow at a faster pace. Meanwhile, the Datadog/Dash0 bill kept climbing, and we still spent engineering hours to learn, configure, and maintain our observability tooling.
With Sentry, we found ourselves flooded by a stream of alerts into our Slack channel, most were duplicates or lacked context, so alert fatigue/constant interrupts were a real pain. The #ops notification is consistently the worst feeling on a Saturday morning
We’ve seen too many times servers run out of memory and disk, and three AWS metrics giving us three different values. Half of the graphs on dashboards are normally empty or outdated, and manually clicking through UIs, especially when the team is small, seems like a huge waste of time.
At some point we realized that solving this problem would be more valuable than the things we had been working on, and we had the expertise to do it, since Arseniy had spent years at Datadog, getting paged during the night to debug production incidents. So we decided to build a platform that would just work: agent-first, MCP-native, zero-setup.
Here’s how Superlog works: we have a wizard that scans your repo, and automatically instruments it with well-structured logs, traces and metrics via OpenTelemetry. We make sure to highlight main failure modes, endpoint performance, usage per tenant, and LLM/upstream cost (by callsite, tenant and model).
Errors get fingerprinted and grouped into incidents, so you see one issue, not a thousand duplicates. When you get a notification from Superlog, you see a clear failure summary, its inferred severity and impact upfront.
Then the agent investigates and tries to solve the issue. If it has enough context, it produces a concise and tested PR. If it doesn't, it posts its findings for the investigating team, and automatically pulls in the engineers that could contribute more context based on documentation, previous investigations and Slack threads.
Either way the output is one clean PR per incident, posted in Slack, that you can
merge, ignore, or open as a Claude Code session and modify.
Three things we think are different from other observability vendors:
(1) We solve the setup pain. The wizard will instrument everything with native OTel SDKs, respecting the semantic conventions, with proper service and environment tagging. We’re also working on native automatic dashboards and alerts, so that you can see what’s going on in a glance and don’t miss subtle failure modes.
(2) Our telemetry doesn’t decay. The wizard runs daily, and keeps adding logs, alerts and dashboards where it’s needed. You don't have to remember to instrument new features. The next time something breaks, the data you need to debug it is already there.
(3) Our goal is to solve alert fatigue. We use agents to merge similar errors and refine the summaries, giving you relevant information upfront. We have a custom evaluation setup that makes sure that our summaries are dense and correct, and severity and impact is on point. We also give you confidence scores for every LLM-enhanced metric so that wrong guesses don’t get boosted.
Important: superlog telemetry is vendor-neutral, so you keep all the logs/metrics/traces we install. Pricing is on the site. We're early, so expect rough edges and please tell us when you find them.
You can try it at https://superlog.sh. We'd love to hear what you're using today, what's broken about it, and whether the "one mergeable PR per incident" model sounds useful or terrifying. Especially keen to hear from folks running integration-heavy products, anyone who's rolled their own observability, and anyone who has tried Sentry / Datadog MCPs and given up. Comments and feedback welcome!

value: Show HN: Superlog (YC P26) – Observability that installs itself and fixes bugs

author: Magnanten


value: patriceckhart

value: Show HN: A small code review extension for zot

author: patriceckhart


value: gokhalh

value: Show HN: Localaik – Run OpenAI and Gemini APIs Locally for CI and Tests

author: gokhalh


value: prasanthj

value: Show HN: hnr – a terminal Hacker News reader vibe-coded in Rust

author: prasanthj


value: echelon

value:
I just heard from a very reputable source that Google built part of our product and that they're about to show it off at Google IO.
We built a 3D film tool called ArtCraft:
https://getartcraft.com
https://github.com/storytold/artcraft (our monorepo with the desktop app, server, and website code)
Our 3D virtual film set enables set decoration, location reuse, precision blocking (control over where things are), character posing, etc.
Sets and objects can be generated as meshes or gaussian splats.
Autoregressive multimodal models can treat input "previz" style scenes as ControlNets of sorts. Combined with reference images and a possibly a few follow-up rounds of editing, you can create extremely precise starting frames that reflect your vision as a director or creative almost exactly as you see it.
It gets rid of the "roulette wheel" of prompting in the places and times where you know you what you want. It's like a WYSIWYG editor.
Here's an example:
https://app.getartcraft.com/edit-3d/m_qa72baw3crghyfn2bbw52j... (Sci-Fi horror film, starring Garry Tan.)
I was just told that Google built a 3D tool similar to ours that they're showing off at Google IO. I don't view this as bad, but I do want to share ours before they get all the attention.
OpenAI's GPT Image is a lot better at this "3D previz to full render" task than Google's Nano Banana, and it's excelled at this workflow since GPT Image 1. (Unless Google shows off a brand new model for the task, I expect this to still be the case.)
Our plan is to build vertical specialized tools for animation, editing, dubbing and make the entire stack - including cloud API routers and model containers - open source.
Here's an example of timeline based animation (and we have the ability to edit animation curves for all objects, meshes, cameras, etc.):
https://imgur.com/a/00q76j2
Our tool has BYOK and subscriptions, so you can use lots of other API providers and even log in with the commercial versions of other models and aggregators. We don't care if we book the revenue directly, we want to build the rails and the UX and win mindshare.
We hit a pretty good growth spurt and have had folks start sending us PRs, which has been exciting.
Eager to see what Google's version of this looks like.
If you're a Rust developer interested in film and media, I'd love to say hi.

value: Show HN: Heard Google copied part of our product for IO. Want to show off first

author: echelon


value: josehbez

value: Show HN: Sentilis – a folder of Markdown files becomes your bio, blog, store

author: josehbez


value: punyaatloomavi

value:
I am a data scientist with 10 years at PayPal.
I built Loomavi during a career break.
One line: you describe what you are feeling or a pattern you keep noticing about yourself. Loomavi decodes what is underneath and gives you the insight as a structured personal letter.
THE PROBLEM
Therapy, journaling, and wellness apps all have real value. This is not a replacement for any of them.
The gap I kept finding was a specific moment.
The moment you catch yourself doing something and think wait, why did I just do that.
Not a crisis moment. Just a curious one.
In that moment you do not need a therapist.
You do not need a 30 day program.
You need something that can look at what you wrote and tell you what is underneath it. Right now.
That moment had nothing built for it.
That is what Loomavi is for.
HOW IT WORKS
You write freely. No prompts, no questionnaires.
Just what is on your mind.
Loomavi processes the input and returns a structured personal letter
Each decode also generates a ritual suggestion,
relevant reading, and citations.
Stack: React, Node.js, Google Cloud Run,
Firebase. Built as a PWA.
CURRENT LIMITATIONS
No memory across sessions yet. Each decode is standalone.
This is the next thing I am building.
Mobile PWA works well but a native app would be better.
TRY IT
loomavi.com
Free tier: 3 decodes, no card required.
Paid plan: $4.99 per month.
FEEDBACK I GENUINELY WANT
Does the letter format feel meaningful or like a gimmick.
Does the first decode experience explain itself without needing instructions.
Where does the free to paid conversion feel right or wrong.
I will respond to everything

value: Show HN: Loomavi-psychological insight tool that decodes what you are feeling

author: punyaatloomavi


value: dtfortu

value:
Hi HN — I built ClassKeep.
The trigger: every small studio owner I know (pilates, yoga, pottery,
even a dog trainer) runs the operational side of their business on
WhatsApp + a Google Sheet, or on one of the expensive incumbents
(Mindbody/Glofox) they actively dislike. The single biggest leak is
last-minute cancellations: someone bails at 6am and the seat just
goes empty, because there's no fast way to notify a waitlist.
ClassKeep tries to remove that end-to-end:
- Public booking page on a free *.classkeep.app slug (custom domain
  optional), with a drag-and-drop page builder so it doesn't look
  like a generic SaaS template.
- Credits, drop-ins, and recurring subscription plans, all via
  Stripe Connect — the studio gets paid directly, I never touch
  the money.
- A waitlist that auto-notifies via email + web push + SMS the
  instant a seat opens; first tap wins. This is the part most
  studios told me they'd pay for on its own.
- 1-tap tablet check-in for instructors so they're not fumbling
  with a clipboard between classes.
- Bilingual (EN + pt-BR) with LGPD/GDPR self-serve export & delete.
Stack, for the curious:
- Next.js 15 App Router, Server Actions for every mutation (no
  REST except the two auth route handlers and the Stripe webhook).
- Drizzle ORM on Postgres.
- Two separate Better-Auth instances — one for studio operators,
  one for students — so cookies and sessions don't collide on the
  same domain.
- Stripe Connect (webhook-authoritative fulfillment), Twilio for
  SMS, OneSignal for push.
- Tailwind v4 with a Material 3 token system.
Pricing: free for every studio during early access — no card, no
per-student fees. Early signups get a permanent discount when paid
tiers ship.
Genuine asks:
1. Try creating a studio and booking a class on it — does the
   flow feel less painful than Mindbody/Glofox if you've used them?
2. Does the waitlist mechanic feel different enough to matter, or
   is it table stakes by now?
3. If you run a studio (or know someone who does), I'd love to
   talk — email in profile.
Happy to go deep on any of the architecture (Server Actions +
Stripe webhook reconciliation was the trickiest part).

value: Show HN: ClassKeep – Booking, credits, and smart waitlists for boutique studios

author: dtfortu


value: gkiely

value:
I’m working on pack.sh, a simple way to deploy apps to your own server.
The goal is to bring back the old zeit now feeling: run one command in a project and get a live URL, but self-hosted.
Instead of managing Node versions or different runtimes on the server, pack.sh uses single-file executables. Build once, upload one file, run it.
This keeps server setup pretty minimal, and makes it easy to run many small apps on a cheap VPS.
Feedback welcome.

value: Show HN: Pack.sh – Self-host single-file apps

author: gkiely


value: pixxxel

value: Show HN: Agent threads – Share Claude Code and Codex sessions as public links

author: pixxxel


value: Show HN: Ait – Claude, Codex, and Aider as a team, on your laptop


value:
Hey HN,
I built libreoffice-rs: a pure-Rust, std-only library + CLI for reading, writing, converting, and rendering office documents — with *zero* LibreOffice, Java, or C dependencies.
100x faster... I know, I know.
It supports DOCX, XLSX, PPTX, ODT/ODS/ODP, PDF, Markdown, CSV, HTML, SVG, and more. The CLI is designed to feel familiar:
```bash
cargo install libreoffice-pure<p># soffice-style usage
libreoffice-pure --headless --convert-to pdf report.docx
libreoffice-pure --headless --convert-to csv spreadsheet.xlsx<p># Markdown extraction
libreoffice-pure docx-to-md report.docx report.md
libreoffice-pure pptx-to-md slides.pptx slides.md<p># Render pages as images
libreoffice-pure docx-to-pngs report.docx pages/ --dpi 144
```

value: Show HN: LibreOffice-rs – I built a pure-Rust LibreOffice using autoresearch


value: zipvoila

value: Show HN: I built an open-source tool to see if ChatGPT recommends your products

author: zipvoila


value: artiomyak

value: Show HN: Symbols Copy and Paste

author: artiomyak

title: Show HN: Symbols Copy and Paste


value: ugnju

value: Show HN: audio.observer – AI news jingles you didn’t ask for

author: ugnju


value: lgogolin

value: Show HN: MailSec – Free email security audit API (one curl, eight checks)

author: lgogolin


value: Show HN: Llama-dash – local LLM operators dashboard and proxy


value: dejobaan

value:
A tool/toy that lets you connect to your Steam wishlist to calculate the total list/current price of all the games on it.
There's a shallow, jokey purpose to it ("I could buy a BMW with this amount!"), but the real purpose is to demonstrate how we can do a better job of portraying a game catalog. I often wishlist stuff, then it pops up in a "Hey, it's on sale!" email months later. In that email, there's a banner capsule, but that doesn't help my brain remember why I added it.
To that end, after you get the bill, you get a nice, flat feed of stuff about all the titles you've wishlisted over the years. It's all stuff that developers painstakingly put together, but which Steam tucks away under the fold of a game's Store page.
Anyway, my wishlist came to about $250. My QA guy is up to $19k. Give it a go; hope you enjoy it!

value: Show HN: How Expensive Is Your (Steam) Wishlist?

author: dejobaan


value:
Hey HN,
I built Crisper because every dictation tool I tried either sent audio to the cloud or gave me raw, messy transcripts I still had to fix.
Crisper runs entirely on-device — no network calls, no account, no subscription. It does two things in sequence: transcribes using a speech model, then runs a local LM pass to strip filler words, fix grammar, and make the output sound intentional. The whole thing takes ~1–2 seconds on Apple Silicon.
A floating hotkey pill sits above every window. When you're done recording, it auto-pastes back into whatever app you were in before — Slack, Notion, VS Code, anything.
A few things I'm happy with:
- Three recording modes (toggle, hold-to-record, re-paste last) — all rebindable
- Full transcript library with source app, timestamp, and audio playback
- Fully offline after first-run model download
Free to download. Would love feedback on the AI polish quality especially — that's the part I'm still tuning.
https://speakcrisper.com

value: Show HN: Crisper – On-device voice to polished text for macOS


value: gillytech

value:
Hi HN, Kevin Gilleard here from GillyTech. I run a digital agency that deals with a lot of WordPress sites and have always been interested in optimizing my WP instances (going back 16 years).
I love to find ways to optimize for speed, security and stability and found myself using a ton of different tools to do performance audits. GTmetrix and Google Page Speed Insights are my go-to's as a starting point. But there were other things I needed to check like security headers, which builder (if any) is used on the site, WooCommerce, caching plugins, CDNs, WAF, etc. So I decided to make my own performance scanner with persistent reports that can be shared with clients and bring those tools together in one custom app. It shows a number of metrics that are specifically important for optimizing WordPress against the three S's: Speed, Stability and Security.
Necessarily this scanner will reject your website if it isn't WordPress, so there is some unique exclusivity here. Full transparency: we do offer a custom WordPress hosting solution and it is advertised on the app but this tool is 100% free to use and does not require any sign-up (three scans monthly but I am sure you're smart enough to figure out how to circumvent that limitation.
I would like you to try it, and let me know your feedback here and any questions. Any other things this should be checking for? I am still very open to more development and change of direction to make it even more useful. My goal is to offer this tool to agencies and in turn get some exposure for my infrastructure offering.
Thank you!

value: Show HN: Website Performance Scanner Specifically for WordPress

author: gillytech


value: isoldex

value: Show HN: Sentinel – browser agent using 3x+ fewer tokens (open benchmark)

author: isoldex


value: amitbidlan

value:
I got really tired of giving artificial intelligence agents access to tools. Then I had no idea what they were actually doing.
So I created Korveo.
Korveo runs on your computer between your agent and its tools.
Here is what Korveo does:
1. Korveo records every single tool and application programming interface call that the agent makes
2. Korveo lets you replay the sessions like a recording of a flight
3. Korveo blocks behavior right away like when the agent tries to leak data or connect to a bad host or when it tries to mix up information from different sessions
All of Korveos work happens on your computer. There is no cloud involved. You do not need to make an account. Everything that Korveo does stays on your machine.
Korveo is still a thing so there are some issues.
For example:
1. The language that Korveo uses to make rules is not good
2. Korveo does not work well with all frameworks
3. Korveo is not a space to test an agent that has been fully compromised
But even with these issues Korveo is already useful if you are working with autonomous agents and you want to see what they are doing and you want to make sure they do not do anything bad.
I would really like to hear your thoughts, on Korveo.

value: Show HN: Korveo – a local firewall for AI agents

author: amitbidlan


value:
Hi HN - I'm Vladimir (Swiper, Framework7, Konsta UI). I've spent two years on cladd, a React UI kit aimed at information-dense application UIs - editors, dashboards, design tools - rather than marketing sites or headless primitives.
Already powering Swiper Studio, t0ggles, PaneFlow, and Start Page HQ in production.
Stack: React 19, Tailwind v4, MIT.
Full breakdown + design rationale in a comment below.

value: Show HN: Cladd – React UI kit for editors, dashboards, and dense app UIs


value: VladoIvankovic

value: Show HN: Codeep – Open-source terminal AI coding agent, multi-provider

author: VladoIvankovic


value: vegnus

value: Show HN: Local LLM code-generation with Gemma 4 e2B via JSON AST to Clojure

author: vegnus


value:
As a Linux user who always envied Spotlight and Alfred, I built LaunchDock to scratch my own itch. It runs a background daemon and can appear by configured hotkey, and the fuzzy search algorithm allows two or three keystrokes getting you to the right app.
Blog post with more background: https://qa3.tech/articles/2025091701

value: Show HN: LaunchDock – App Launcher in Rust


value:
I'm a recent grad from UMich and built AgentShield because agentic AI is moving fast but payment safety hasn't caught up. Agents are already being handed API keys, stablecoin wallets, and payment credentials - if one misbehaves, gets prompt injected, or makes a bad call, nothing understands the agent's intent well enough to stop it.
Every spend request runs through four checks before money is allowed to move:
1. Quantitative (Redis) - Is the agent within its daily budget? Is it sending the same transaction over and over?
2. Policy (Postgres) - Is the vendor blocked? Is the amount too high to auto-approve? Is the stablecoin/network/address allowed?
3. Semantic (Claude Haiku) - Does the stated goal actually match what's being purchased?
4. Goal Drift (Claude Haiku) - Is this purchase within what the agent is supposed to be doing at all?
Checks 1 and 2 run sequentially — if either hard-denies, Claude never gets called. Checks 3 and 4 run in parallel via asyncio.gather.
One verdict comes back: SAFE, SUSPICIOUS, or MALICIOUS.
Full product — live dashboard, auth, HITL approval flows, spend monitoring. Completely free.
Looking for feedback, especially from anyone running spending agents in production.
Landing page: https://agentshieldv2-dashboard-production.up.railway.app
Demo: https://youtu.be/tJIYp8yOpuo?si=4oV1d_p9Tx9w8DhT
Github: https://github.com/lucarizzo03/AgentShieldv2

value: Show HN: AgentShield – Stop AI agents from spending money unsupervised


value: devopsian

value:
I’m sharing the 3rd version of a side project I’ve been building for every major tournament since 2022. It’s called Bench-Bets, and it’s a simple way to run prediction leagues for the 2026 World Cup with friends.
During Euro 2024, the app reached 7,000 users. I was running it on Fly.io and, despite the great DX, I realized I hadn't spent enough time on my caching strategy. I ended up hitting over 100GB of outbound traffic in a month for what is essentially a text-heavy app. For v3, I’ve spent my time rethinking the data-fetching architecture and ensuring I'm not "re-downloading the world" on every match update.
The tech-stack:
- nuxt v4 & tailwind
- sqlite + drizzle ORM. I’m a huge advocate for SQLite in production for these types of hobby apps—it’s fast, simple, and the performance for thousands of concurrent users has been surprisingly solid
- auth: Better Auth
The rules:
It’s the standard "guess the score" format, but I’ve added a twist where points double starting from the Round of 16 to keep the leaderboard competitive until the very end.
I built this because I wanted an ad-free, tracker-free alternative to the cluttered betting apps out there. It’s just me and a few friends playing, but it’s been a fun way to learn about modern web architecture and the "surprises" that come with even modest scale.

value: Show HN: Bench-Bets – A World Cup Prediction App Built with Nuxt and SQLite

author: devopsian


value: techedlaksh

value:
I run YourEventKit, an independent directory of event technology tools.
Over the past few months I collected and enriched 271 tool profiles with structured data, and once that was done, I wanted to do something fun with it.
So event tech wrapped is the result of my fun curiosity while playing with the dataset. Its a scoll-driven data story where one SVG constellation of 271 dots morph through 10 different states as you scroll.
Each dot is a tool. Each state is a different lens shining upon the dataset.
Built with Astro and D3. The 10 layouts are precomputed with D3 force simulations at build time, stored as JSON. Scroll position interpolates between states via requestAnimationFrame -- no runtime simulation.
Some findings that surprised me:
- Only 54% of tools publish a real starting price. The rest require a sales call.
- 150 out of 271 tools say they are not built for small or one-off events.
Some of you might be able to see the influence of Shirley wu, Emil Kowalski and FiveThirtyEight
All observations and questions are welcome. The experience is enjoyed over desktop as I could not figure out a good experience for mobile yet.

value: Show HN: I reviewed 271 event tech tools and turned the data into a visual story

author: techedlaksh


value: curatedmcp

value: I built a local proxy that dedupes Claude Code traffic. TokenShield — cuts your Claude Code bill 40-70%

value: Show HN: TokenShield – Local proxy that dedupes Claude Code conversation traffic

author: curatedmcp


value: tee-es-gee

value: Show HN: Pg_deltax, Apache-licensed alternative to TimescaleDB

author: tee-es-gee


value:
I previously shared a mechanism for voting on .AI sites.
It was something I built just to explore what's going on in this part of the internet.
I wanted more comprehensive data. So I've added AI generated structured categories and a description for each of the sites, so it's easy to find players within specific niches.
I'm creating a much much larger dataset (not just .AI websites).
Let me know if any of this is of interest (will share for free if it's for research purposes).

value: Show HN: Search 67K .AI domains by AI-extracted tags and descriptions


value:
Hi HN. I've been building this for the last few months and it's at a state where outside eyes would help more than another week of solo iteration.
It's a kanban board where each ticket runs two agents back to back:
Build agent: runs in a sandboxed temp dir against a shallow clone of the user's repo, makes the change, pushes a branch, opens a PR. Uses the Claude Agent SDK.
QA agent: waits for the preview deploy to come up, then drives a real browser via Browserbase against the preview and verifies the change works against the ticket's acceptance criteria. Screenshots and an mp4 of the QA session get attached to the PR.
If QA fails, the build agent reruns with the QA report as context, up to 3 iterations. Before each retry, a classifier reads the failure and decides whether it was a real code bug or environmental (Clerk didn't load, preview never deployed, Browserbase session got 403'd, etc). Environmental failures break the loop instead of iterating on infra noise. This was the single biggest reliability win.
The other side is input. The platform exposes an MCP server, so from Claude Code or any MCP client you can say "make a ticket for X" and it lands in the backlog. The original reason I built any of this was that writing tickets was the bottleneck for me, not writing code.
A few implementation notes that might be interesting:
The build agent's system prompt forbids the Task / Agent (subagent) tool. Spawning subagents inside the SDK was hanging for 4+ minutes consistently. Staying in the main session with Read/Edit/Bash/Glob/Grep is dramatically more reliable.
Postgres schema is applied on startup from a single schema.sql, idempotent with IF NOT EXISTS everywhere. No migrations directory. Adding a column is "edit schema.sql, push, restart." This is the highest-leverage decision I've made on the backend.
QA has a fast mode (local Chromium for anonymous routes) and a deep mode (Browserbase + residential proxies + stealth, for anything behind auth). The mode is per-ticket because cheap-and-fast loses signal once you go past the login wall.
A background sweeper force-fails any job running over 60 min. The SDK can hang in ways asyncio.wait_for doesn't always clean up through the subprocess boundary, so the kill switch is a belt-and-suspenders guard.
Stack: FastAPI on Railway, Postgres, Claude Agent SDK, Browserbase, Vercel for previews, Clerk for auth, Resend for transactional email, MCP over HTTP. Frontend is one HTML file on Vercel, no build step, no framework, just vanilla JS and Clerk loaded from CDN.
What's not working well yet: deep-mode QA still occasionally gets stuck on CAPTCHAs in unfamiliar OAuth flows. The classifier's environmental-failure list is hand-curated keywords, which is fragile. Spend tracking is per-job but I haven't built per-workspace budget caps yet. PR previews on Vercel sometimes take 2-3 min to come up which the QA agent has to wait through.
It's in alpha with a waitlist. Free during alpha, paid plans later. The whole platform was built using Claude Code, so this has been dogfooding itself for the entire build.
Site: https://notesasm.com
Would love feedback, especially on: the dual-agent loop design, the classifier approach, what kinds of tickets would actually break this on your repo, and prior art I should be aware of (I know about Devin, OpenHands, SWE-agent; what else?).

value: Show HN: Coding agent where a second agent QAs every PR in a real browser


value: ombedzi

value:
Hi HN - author here.
FastBackend reads a SQLAlchemy or Prisma schema, compiles it to a framework-agnostic IR, and a runtime adapter serves CRUD + relationships as REST with OpenAPI on the side.
Try it in ~2 min:
    npm i -g @fastbackend/cli
    git clone https://github.com/darula-hpp/fastbackend
    cd fastbackend/examples/sqlalchemy-fastapi
    pip install -r requirements.txt
    fastbackend generate && fastbackend dev
    open http://localhost:8301/docs
What's shipped:
- CLI + core on npm (@fastbackend/cli 0.1.2)
- FastAPI adapter on PyPI (fastbackend-fastapi)
- Express + Prisma adapter on npm
- Custom routes and overrides for non-CRUD logic
Honest limits:
- FastAPI adapter uses in-memory storage (MVP)
- Express + Prisma is more production-shaped
- No hosted platform — self-hosted codegen/runtime
The IR is the interesting part: same schema could be served by different backend adapters. OpenAPI is the frontend handoff (Orval, openapi-typescript, etc.).
Roadmap (not shipped): declarative wiring for storage/OAuth with secrets in .env.
Happy to answer architecture questions or comparisons to Supabase, PostgREST, FastAPI-CRUD, etc.

value: Show HN: FastBack end – schema-first back end runtime with OpenAPI output

author: ombedzi


value: squirrelon

value:
Melogen generates short melodic phrases as .mid files, no rendered audio, just notes you drop into your DAW. Free to try, no signup required.
I built this because every "AI music" tool I'd tried produces finished audio, which is the opposite of what I want when I'm stuck on a hook. I wanted something that hands me a MIDI seed I can take into Ableton/FL/Logic and shape myself.
Under the hood:
- Decoder-only transformer trained on MIDI
- Outputs note sequences with timing and velocity
- Tuned for short, usable phrases rather than full arrangements
It's still in beta and rough in places. I'd value blunt feedback on:
- Whether the generations are actually musical, or just "notes that fit a key"
- MIDI handling: timing, velocity, channel assignment
- What's missing before it would slot into a real workflow
Happy to get into the model, dataset, or pipeline in the comments.

value: Show HN: Melogen – Generate MIDI melodies for free

author: squirrelon


value: nimeshmc

value:
TL;DR: logbox is an open-source tool that pipes dev server logs to a local sqlite db with `<your-dev-server-cmd> | logbox collect`. Give Claude Code access by running `claude mcp add logbox -- logbox serve`.
I used to copy & paste logs into Claude Code when manually testing my server in dev. I wanted to give it its own verification loop.
I initially tried having it boot the server itself and follow the logs. It was good at knowing if the server booted properly, but it capped out and missed details when the logs started flowing in.
I also tried piping the logs to a local file and telling Claude to read them from there. It worked, but became annoying once we had multiple services or wanted to reference past dev server sessions.
So I built logbox for ourselves at Struct and decided to open-source it. It’s a simple Rust CLI that pipes logs into a local SQLite db with an MCP server that gives coding agents the ability to search them.
Once it could reliably monitor the dev server logs totally autonomously after testing its changes, I stopped needing to fish for log snippets and keep nudging it to get a manual test working end-to-end.
Everything stays local. `logbox serve` is an stdio MCP server and it just works with the local SQLite db.

value: Show HN: Logbox – let Claude monitor your dev logs

author: nimeshmc


value: andrewsokolov

value:
Hi HN, I’m the maker of ExtraBrain.
I built it because I kept running into the same problem in high-pressure live conversations: the call moves faster than my notes. By the time I’ve captured the prompt, constraints, edge cases, or action items, the conversation has already shifted.
ExtraBrain is a Mac desktop app that gives you a private live workspace during interviews, meetings, lectures, and research calls. It can transcribe the session, keep track of context, help structure answers or follow-ups, and turn the session into notes afterward.
A few things I cared about while building it:
It’s local-first: transcripts, screenshots, prompts, and notes can stay on your Mac.
It supports local transcription / local models where installed and compatible.
You can bring your own OpenAI, Anthropic, Claude, Codex, or compatible provider access.
It does not join your meeting as a bot.
The free version is usable; Pro adds workflow/history/profile features.
I know the interview-assistant category is sensitive. My intent is not to help people misrepresent their skills. I’m trying to build a tool for live thinking, accessibility, note-taking, preparation, and post-session review. People should still follow the rules of their interview, school, workplace, or platform.
I’d especially love feedback on:
whether the local-first/privacy model is clear enough
whether the setup feels too heavy for a normal Mac user
what responsible-use boundaries you’d expect from a tool like this
whether “meeting copilot” or “interview copilot” better explains the product
Mac version is available now: https://extrabrain.app
Happy to answer questions, and genuinely curious where HN thinks this kind of tool should draw the line.

value: Show HN: ExtraBrain - local-first desktop copilot for live calls

author: andrewsokolov


value: Show HN: Yt-x v0.8.0 – Browse, play, and download YouTube from the terminal


value: brettcodes

value:
I love making small 2D pixel art games, especially using tools that have some constraints. Things like Pico-8 and the Playdate SDK are simple, fun, and allow for focusing on the game idea rather than the technical minutia. Years ago I prototyped an idea for this little game engine, Usagi, but used Rhai instead of Lua. The idea for this little game engine never went away, so I decided to finally dig in and build it.
Today I released v1.0.0 of Usagi Engine after making a bunch of small games, getting feedback from developers, and stabilizing the API. It's simple, has a great developer experience (CLI-based, init template, Lua plugin integration, and cross-platform export for web, Linux, macOS, and Windows with a single command).
The engine is public domain, and its source is on GitHub (linked from the website).
Rust was a great fit for this project due to its stability and tooling. The crate ecosystem is a real highlight for me. Plus clippy. I made a couple of games in Rust in the past (using Macroquad) which prepared me for this project. But for Usagi I decided to go with Raylib for it's maturity. Usagi is using sola-raylib, the Rust bindings for C Raylib with some Rust-y wrappings. I maintain these bindings, which also was a big help to be familiar with what's possible with Raylib.
The well known tools that are similar are Pico-8, Picotron, Love2D, and DragonRuby Game Toolkit. They all have their strengths and weaknesses. I think Usagi fits in a little spot amongst them where it's free, open source, and has a much more modern developer experience.
Now that the engine is v1.0.0, I'm going to focus my energy on making games with it, writing a book of tutorials, and creating video screencasts. I love sharing what I learn and helping people make their games.
I'd love it if you checked the engine out, and I'm looking forward to seeing what people make.

value: Show HN: I made a 2D Lua game engine using Rust with code and asset live reload

author: brettcodes


value: yamafaktory

value: Show HN: HypergraphZ – directed hypergraph library in Zig with Python bindings

author: yamafaktory


value: carvil

value:
My kids love maths. A key part of that is being at ease with the fundamentals - if a kid struggles with the fundamentals, it’s hard to build confidence on top of that. One of those fundamentals is being really good at times tables. At home we’ve always tried to make learning fun, and enjoyed adding a little competition to it too.
At school (an international school in Portugal for english-speaking students), they also use lots of fun strategies to teach kids their times tables. One of those is called 5 Minute Frenzy. It consists of a matrix printed out on paper, usually 10x10, with random multiplication questions that students have to fill in. The goal is to fill in as many as possible within 5 minutes. The kids love the challenge and the competitive nature of it.
Doing it on paper is cool, but not practical all the time…
So I built a free digital version of that. No email needed, no tracking, no personal data collected.
There’s just a lightweight username + a 4-digit pincode if kids want to rank on a leaderboard (not needed to play the game), and track progress via a GitHub-style heat map showing accuracy per times tables.
Technically speaking, it’s pretty basic - a next.js app, with Postgres under the hood for users, games etc, deployed on a digital ocean droplet.
I think the badges/leaderboard piece needs quite a bit of iteration, it might be too easy to climb up the ladder right now, but I’m experimenting with kids and seeing what lands.
What do you think?

value: Show HN: 5 Minute Frenzy – free multiplication practice game for kids

author: carvil


value: Show HN: ECD++ 2026.3.10 Is Released

title: Show HN: ECD++ 2026.3.10 Is Released


value:
The DDS Vibe Academy is a free, 31-class curriculum on AI coding. It covers Claude Code, Google Antigravity, Gemini 3.1 Pro, Cursor, Shopify Sidekick, Ollama, Hydrogen 2026, and AI Cost Engineering. No paywall, no signup, no certificate.
The academy hub itself was built by AI agents. Claude Opus 4.7 authored 12 Liquid sections (~6,400 lines). Google Antigravity deployed every file to Shopify via the Shopify MCP. Cowork ran an autonomous browser audit. I did not write a single line of code or upload a single file manually. I designed the constraints. The agents did the implementation.
The curriculum spans four stages. Foundation onramps for Sidekick and Ollama. Development masterclasses on Claude Code and Cursor. Application-stage case studies documenting systems like the Sovereign Orchestrator and NicheForge. Mastery-stage forensic records of multi-agent AI infrastructure. A sister blog publishes Monday through Friday.
Read whatever you want, whenever you want: https://ddsboston.com/pages/dds-vibe-academy?utm_source=hn&u...

value: Show HN: DDS Vibe Academy – 31 free AI coding masterclasses, built by AI agents


value: umbertotancorre

value:
I have a long YouTube watch-later playlist and wanted Claude to help me triage it by summarizing each video. It couldn't. I later discovered YouTube is not accessible to Claude, ChatGPT and majority of AIs. So I built this MCP server to fix that.
This is a local MCP server that gives any MCP-compatible client (Claude, ChatGPT, OpenClaw and others) 8 tools for working with YouTube content:
- fetch full transcript, with or without timestamps
- download transcript as a .md file
- get video metadata (title, channel, views, duration, likes, description)
- search within captions for a keyword or phrase
- download video or audio
No YouTube API key. No account. No signup. Everything runs locally on your machine against publicly available data.
Setup is one line:
npx @umbertotancorre/youtube-mcp
yt-dlp and ffmpeg are bundled automatically during install, so there's nothing to configure manually.
It's free and MIT licensed. Feedbacks are welcome.

value: Show HN: YouTube MCP, give any AI agent access to YouTube

author: umbertotancorre


value: renatomignone

value:
I was job hunting across countries and kept running into the same two problems.
First: every platform optimises for different things. LinkedIn wants keywords. ATS parsers want specific formatting. GitHub rewards README quality. A portfolio has to be crawlable. Staying consistent across all of them without a system is nearly impossible.
Second: every AI agent session starts from scratch. Paste a context dump, watch it burn half the window fetching your links, get generic output. The agent has no grounded facts about you – so it improvises.
Both problems point to the same fix: one verified source of truth, written once, readable by humans and agents alike.
That's AgentKit SEO [1]. The core concept is an agent-context file – a private Markdown document with your career facts, project metrics, and proof links. You build it once using the context skill. Every other skill (LinkedIn, GitHub, CV/ATS, portfolio, X) reads from it.
It ships as a CLI that installs focused skill files into whichever agent you use:

  npx agentkit-seo install --provider codex
  # or: claude-code, gemini-cli, opencode, or portable SKILL.md

This is not an auto-apply tool. It's the step before that: create one grounded file, then use it as input for any agent, any platform, any task. No hallucination from context overload. No contradictions between your CV and your LinkedIn.
Open source, free, MIT licence. My co-author Elia Innocenti and I built it because it didn't exist.
[1] https://github.com/agentkit-seo/agentkit-seo
[2] https://agentkit-seo.github.io/
[3] https://www.npmjs.com/package/agentkit-seo

value: Show HN: AgentKit SEO - a career context file that installs as agent skills

author: renatomignone


value: knotalegend

value: Built Bevel because my girlfriend is in a book club and I wanted to make her something. It’s a daily puzzle: you read a 200ish-word public-domain passage and try to deduce the author, decade, nationality, and title in five guesses with adaptive hints in between guesses. Wordle-ish mechanics, but for classic literature. There’s a Discord activity too if you enjoy it & want to add it to your server. Bevel is currently unverified on Discord, so only addable to smaller servers for now. Would love any feedback.

value: Show HN: Bevel – Guess the book from its opening passage

author: knotalegend


value: Show HN: PoC - VPN over WebRTC to Bypass Whitelists


value: Show HN: A macOS menu bar app for monitoring live Claude Code sessions and usage


value: dantelofisial

value:
Sysadmins find out about a broken Windows update three ways: a user ticket the
morning after Patch Tuesday, an r/sysadmin thread 48 hours later, or Microsoft's
own Known Issues page 1–3 weeks deep. There's no central feed of "this KB broke
this thing on this config." Bleeping Computer and AskWoody are the closest, but
slow and unstructured.
So I built one.
What it does:
- Pulls posts every 4–6h from r/sysadmin, r/msp, r/Intune, r/ActiveDirectory,
  r/exchangeserver, r/AZURE via the Reddit JSON API
- Pulls RSS from MS Health Dashboard, Bleeping Computer, AskWoody, BornCity,
  MS Security Blog, and the Windows IT Pro / Intune / Exchange TechCommunity
  boards
- Groups by (primary KB, component) so 12 threads about the same 802.1X bug
  become one row with 12 source links
- Ranks by score + post_count + recency
- Optional Thursday digest email via Resend
Every regression row links back to the underlying Reddit/RSS posts — the
classifier is not authoritative, the source threads are. If the LLM misreads
something the evidence is one click away.
What I'd love feedback on:
- Sources I'm missing. Specifically non-English ones (BornCity is the only DE
  source right now; nothing for JP/KR where MS ships region-specific KBs).
- Classifier failure modes. Edge cases where it's calling things regressions
  that aren't, or missing real ones.
Free to read. Digest signup is optional. I'm the only person on it.

value: Show HN: Crowdsourced tracker for what each Windows/M365 update breaks

author: dantelofisial


value: VanceVP

value:
Hi HN,
I built Limitless because I wanted to create a unified, high-fidelity platform for Open Source Intelligence (OSINT), dark web collection, and interactive threat training.
Most cybersecurity training systems are either standard slide decks or text-heavy questionnaires. At the same time, actual analyst tools are scattered across hundreds of disconnected command-line scripts and API wrappers.
Limitless merges real analyst tools with a reactive, browser-based training simulator.
The Ecosystem Components:
1. *Feynman (OSINT search): An intelligence search engine that maps digital footprints, uncovers hidden connections, and aggregates intelligence across 200+ online sources instantly.
2. *Sentinel (Darknet Agent):* An autonomous AI agent designed for deep-web collection, learning, and reasoning across darknet forums.
3. *Interactive Training Sandboxes:* Scenario-driven tutorials that teach cybersecurity operations through visual tools:
   * GEOINT Simulator: Uses Leaflet and coordinates to calculate physical proximity (Haversine formula), supporting tolerance radii and partial scoring.
   * Steganography Lab: Toggles Red/Green/Blue color channels and bitplane depths on canvas elements dynamically in the browser.
   * Draggable Chronology & Classification: Drags event timelines and classifies logs using `@dnd-kit`.
   * Audio & Video Intel: Custom playback speed modulators and zoom canvas overlays.
Localization: Reactive, real-time translations supporting 9 languages (English, Spanish, Portuguese, French, Russian, Hebrew, Arabic, Japanese, and Hindi).
You can explore the interactive intelligence based sandboxes for learning directly https://limitless-osint.com/
I’d love to hear your feedback on the investigative tools (Feynman & Sentinel), the workspace user experience, or what intelligence tools you would like to see us build next.
Thanks!

value: Show HN: Limitless – AI OSINT search and interactive intelligence sandboxes

author: VanceVP


value: zobweyt

value:
Hi HN!
I've built a plugin for Obsidian that adds lightweight, highly customized, and native-feeling chart layouts (Bar, Line, Pie) specifically for the new database-like "Bases" feature.
Repository: https://github.com/zobweyt/obsidian-bases-chart-layouts
Plugin page: https://community.obsidian.md/plugins/bases-chart-layouts
### The Problem
I needed a way to visualize my structured note data in Obsidian without the bloat. Existing chart solutions either required writing complex JavaScript inside codeblocks or felt like heavy web-views slapped onto the app.
I wanted charts that feel like a built-in, core feature of Obsidian—lightweight, snappy, and deeply integrated with the UI.
### What makes it "Native-Feeling"
It goes beyond basic SVG rendering to mimic Obsidian’s native desktop UX patterns:
- *Interactions:* Full support for `cmd/ctrl + click` and middle-click (`auxclick`) to open underlying data files in new tabs or split panes.
- *Context Menus:* Right-clicking the chart triggers native Obsidian context menus, not generic browser ones.
- *Theme Adaptation:* It doesn't just switch light/dark modes. It dynamically inherits your exact Obsidian theme CSS variables and fonts.
### Tech Stack & DX
I wanted to keep the codebase as clean as the UI:
* *No Node/NPM Boilerplate:* The entire project is built purely with Deno (fmt, lint, build). This kept the development environment exceptionally lightweight and fast.
* *Rendering:* Powered by Apache ECharts under the hood for crisp vector rendering. The final plugin size is only ~1MB.
* *I18n:* Built-in localization support (currently English and Russian).
### How to try it
1. Ensure you have Bases enabled in Obsidian.
2. Add a chart layout to your view.
3. Map your columns using the native Properties panel.
I’d love to hear your thoughts on the UX integration, and especially on using Deno for building Obsidian plugins. Any feedback or feature requests are welcome!

value: Show HN: Native-feeling charts for Obsidian Bases, built with Deno

author: zobweyt


value: rohitguptap

value: Show HN: Enforra – open-source action governance for AI agent tool calls

author: rohitguptap


value: franze

value: Show HN: Cable Detective

author: franze

title: Show HN: Cable Detective


value: carban

value:
I want to share with you a project I've been working on
Postbear is a high-speed, lightweight API client designed for developers who live in the command line.
No heavy Electron apps, just simplicity.
I already share it before, just want try more luck this time :)

value: Show HN: Postbear The API Client your terminal has been waiting for

author: carban


value: GiornoJojo

value:
Gx HN,
We built SharpSkill in order to add another angle for the technical interviews' process.
Just a Leetcode Alternative to give other insights.

value: Show HN: SharpSkill – A LeetCode Alternative with real interview outcomes

author: GiornoJojo


value: shanirshad

value:
I built PrismoDev after noticing my Claude Code and Codex sessions were getting expensive in ways that were hard to explain.
After digging through local session logs, the recurring issue was not just model pricing. A lot of the waste came from context bloat: generated artifacts, logs, build output, oversized CLAUDE.md / AGENTS.md files, repeated tool output, broad repo exploration, stale session state, and command loops.
PrismoDev is a local CLI that scans a repo plus local Claude Code / Codex logs and tries to explain where token/context waste is coming from. It does not require API keys or login, and nothing leaves the machine.
A few commands:
```bash
npx getprismo doctor
```
Scans the repo, flags missing `.claudeignore` / `.cursorignore`, oversized instruction files, generated artifacts exposed to agents, and creates compact `.prismo/` context summaries.
```bash
npx getprismo watch
```
Monitors live context pressure during a coding session and warns about repeated file reads, artifact leaks, oversized tool output, and possible loops.
```bash
npx getprismo cc timeline
```
Builds a postmortem timeline showing where context spikes, repeated reads, command loops, or generated artifacts appeared in a session.
There are also scoped context policies:
```bash
npx getprismo firewall auth-bug
```
which creates a task-specific context boundary before starting work.
The main idea is to make AI coding sessions easier to reason about before the bill surprises you: what got loaded, what repeated, what could have been avoided, and what should be ignored next time.
Repo: https://github.com/shanirsh/prismodev
I’d be especially interested in feedback from people using Claude Code, Codex, Cursor, or similar tools on larger repos. I’m trying to tune the false positives and find more real-world waste patterns.

value: Show HN: PrismoDev – local CLI for finding token waste in Claude Code/Codex

author: shanirshad


value: rajatarya

value:
I built Markdown Viewer because every Markdown app I found was either bloated (VS Code, Obsidian) or too bare-bones. Wanted something that loads instantly, renders Obsidian-style features cleanly, and weighs in at a few megabytes.
Built with Tauri 2 (Rust backend + webview frontend):
 - GitHub Flavored Markdown + Obsidian extensions (wikilinks, callouts, emoji, math, Mermaid diagrams)
 - Frontmatter rendered as a structured metadata bar above content
 - HTML sanitization via ammonia for security
 - No heavy dependencies, no Electron
What makes it interesting isn't so much the features — but how it was built. Every line of Rust, CSS, and JavaScript was written by AI coding agents (pi.dev/Qwen and Claude Code) without a single human writing code. No hand-holding, no "prompt then copy-paste" — just a high-level brief and iterative agent-driven development.
I've been using this project to hone into my pi.dev setup - am getting somewhere with pi.dev/Qwen3.6 with a small set of extensions. Trying to avoid Claude Code/Opus for this project - want to see what I can do with local LLM.
Key stats:
 - Instant load (no webview overhead, pure rendering)
 - ~few MB binary
 - Sanitized HTML via ammonia (XSS-safe)
 - Open source on GitHub
Open source at https://github.com/rajatarya/mdviewer

value: Show HN: I built a native macOS Markdown viewer 100% with AI coding agents

author: rajatarya


value:
Hi HN, I’m building AgentWing.
The idea is simple: AI agents usually execute work as one long sequence:
plan → act → wait → observe → act again → verify → finish
That makes agent workflows feel slow, especially when parts of the task do not actually depend on each other.
AgentWing adds a director layer that turns one agent task into multiple isolated worker runs. The director decides which parts can run at the same time, assigns each worker its own scoped job, runs them in parallel, then verifies and combines the result.
For an enterprise-grade setup, each worker can run inside its own isolated VM or sandbox, so every agent has its own environment, files, tools, and execution boundary.
Example:
Task: “Research a market and prepare a competitor summary.”
A normal agent may do this sequentially:
- find competitors
- analyze pricing
- compare positioning
- look for user complaints
- write summary
AgentWing can run the independent parts in parallel:
- worker A finds competitors
- worker B analyzes pricing
- worker C checks positioning
- worker D gathers user complaints
- verifier combines the final result
The goal is to make agent tasks feel much closer to instant by removing unnecessary sequential waiting.
I’m experimenting with two modes:
- split mode: different workers handle different parts of one task
- race mode: duplicate workers try the same subtask and the best verified result wins
This is still early. The hard part is the director: deciding what can safely run in parallel, what must stay sequential, and how to verify the final output.
I’d love feedback on where this breaks, what workflows would benefit most, and what demo would best show the speedup.

value: Show HN: AgentWing – make AI agents complete tasks faster


value: cbrinicombe

value: Show HN: Trophy UI, Open-source gamification components built on Shadcn

author: cbrinicombe


value:
I built Remindy because I wanted a faster way to create reminders on my Mac without opening a todo app or turning small follow-ups into a task management system.
It works like a small Spotlight-style reminder bar: press a global shortcut, type something like “check the oven in 20 minutes” or “write a weekly report every Friday at 5 PM”, hit Enter, and get back to work.
It supports recurring reminders, natural reminder input in 10 languages, and native macOS notifications. Reminder content stays local on your Mac. No account, no cloud sync.
It’s free right now while I learn how people use it. I’d love feedback from Mac users who rely on quick capture, reminders, or keyboard-first workflows.

value: Show HN: Remindy – A Spotlight-style reminder app for Mac


value: Show HN: Reckoner – a semantic browser for structured data


value: vforno

value: Show HN: Gutenberg – Any URL to verified CLI and MCP server and agent skills

author: vforno


value:
Before this, I worked in strategy consulting at McKinsey and later in product and corporate strategy roles at Cisco. One pain point I kept seeing: many teams need high-quality strategic analysis, but they do not have a realistic way to get it.
If you are a large company, you can hire a consulting firm. But that often costs $100K+ and takes months. If you are a smaller or mid-sized team, you usually rely on internal analysis, spreadsheets, scattered research, or ChatGPT. Those can help, but they often leave you with the same problem: you still need to know what question to ask, what framework to use, what evidence is missing, and whether the recommendation is actually decision-ready.
We built NitroLens AI to make consulting-style strategy work more accessible through AI agents.
The product starts with a strategic question, such as:
Should we enter this market?
How should we price this product?
Which growth channel should we prioritize?
What should our AI transformation roadmap look like?
NitroLens then runs a structured workflow:
clarifies the business problem
selects a relevant strategy framework
builds an analysis plan
asks for specific internal context or data when needed
runs external research and analysis through specialized agents
tests hypotheses
produces an executive-ready strategy report or presentation
The goal is not to replace human judgment. The goal is to give teams a structured strategy process they can actually use, especially when traditional consulting is too heavy and general-purpose AI is too open-ended.
We’re opening public beta now. Selected users get 1,000 free credits to run a full strategy project.
Beta access: https://tally.so/r/gDQv9P
Demo video: https://youtu.be/2yykqq5kgoE
Example outputs: https://1drv.ms/b/c/0bb8bd164e52642b/IQBTOcLhUtzTTZZPDELtdTk...
I’d love feedback from HN on:
whether this feels meaningfully different from using ChatGPT/Claude directly
what would make AI-assisted strategy analysis more trustworthy
where you think this workflow would break down
what kind of business questions you would or would not trust an agent to help with
Happy to answer questions.

value: Show HN: We built an AI strategy agent that runs consulting-style workflows


value: Show HN: claude-autopilot, autonomous dev pipeline with multi-model review


value: aleqs

value:
Hi HN, I have been working on alint for the last little while. It is a linter for the shape of a repository rather than the code inside it. clippy, ruff, eslint, and others already handle the AST and code space. alint checks the other layer: required files, filename conventions, content patterns, structured values inside package.json / Cargo.toml / GitHub workflow YAML, and cross-file invariants. You write one .alint.yml describing what the repo should look like, and it runs in CI. Today it covers 70 rule kinds across 13 families, 19 bundled rulesets, 12 auto-fix ops, and 8 output formats including SARIF.
To check the design against reality, I built (vibed) working configs for 30 real OSS repos. The corpus is deliberately varied: single-language workspaces and polyglot monorepos, from small clean trees up to roughly 150k-file mega-repos, with and without mature in-house tooling. Each one has a writeup of what alint catches that the repo's existing tooling does not, including the false-positive-in-spirit cases; the configs are committed under examples/ so the claims are checkable instead of asserted. Findings span large-scale verify-script consolidation in mega-repos, real Trojan-Source bidi-control characters in archived release notes (caught by the bundled oss-baseline ruleset), and the usual CI hygiene drift.
The benchmark is the project's strongest discipline, every release is thoroughly benchmark-gated - see docs/benchmarks for methodology and results. 0.2s-1.5s for 100k file repos, 5s-15s for 1m file repos.
Test discipline is layered: unit tests, declarative YAML end-to-end scenarios, property-based invariants, smoke fixtures that pin rule semantics so an ignored knob is caught at PR time, and the benchmark gate. The project is dual-licensed Apache-2.0 OR MIT, telemetry-free (the only outbound is an extends: URL you wrote yourself, SRI-pinned), reproducible build, one static binary. Install: cargo install alint, a Homebrew tap, a distroless Docker image, an npm shim, or a GitHub Action.
The roadmap is public under docs/design/. Near-term: broader extensibility (richer plugin surface, more bundled rulesets) and a few high-demand rule kinds the case studies surfaced.
The fit with coding agents has been getting the most interest lately. Agents make exactly the structural mistakes alint catches: a stray .bak file, a scratch PLAN.md at the repo root, a committed console.log, drift off the repo naming convention. A --format agent output emits per-violation instruction strings an agent can act on, and alint export-agents-md writes the active ruleset into an AGENTS.md or CLAUDE.md section.
What it deliberately does not do is parse code. If a check needs an AST or type information, that belongs to clippy or eslint and alint stays out of it. On bazel roughly 29% (15 of 52 checks) are out of scope for exactly that reason, and the writeup breaks down which and why.
I am open to all kinds of feedback: pain points, things that should be primitives and are not, install or first-run friction, naming, DSL ergonomics (the JSONPath dashed-key bracket-form papercut has caught everyone), ruleset coverage. If you try it on a repo of yours and it falls over, that is the feedback I most want to hear.
Repo: https://github.com/asamarts/alint
Site and docs: https://alint.org
Benchmarks: https://alint.org/benchmarks/
The 30 example configs: https://alint.org/examples/

value: Show HN: Alint, a fast linter for repository structure and hygiene

author: aleqs


value: streaming

value: MediaMolder is a ground-up rewrite of FFmpeg's interface and orchestration layer, built directly on the same libav* media libraries. Written in Go, it includes a React GUI that runs in your web browser. Import, view, validate, run and monitor your FFmpeg jobs (command lines, which are really graphs). If validation fails, MediaMolder will suggest and can implement a fix. You will see per-node performance statistics as your job runs. There is an initial implementation of a real-time mode, which monitors and dynamically optimizes your running graph, in order to achieve and maintain real-time frame rates. When your graph is perfected, hit the “-> FFmpeg” button to see the equivalent FFmpeg command line.

value: Show HN: MediaMolder – A Modern Rewrite of FFmpeg

author: streaming


value:
You know that feeling when no one reads the documentation you wrote? I bet we've all experienced that moment when, after spending a lot of time crafting a README file, you realize nobody gives a fuck.
But how do you know nobody reads your Readme, I hear you ask?
Well, come on, remember when your colleague or manager asks for a call to quiz you on things you already carefully detailed in the docs?
And now? AI agents - which are basically LLMs trained on human data - expect you to have an `AGENTS.md` file. This is on top of the `README.md`, `CONTRIBUTING.md`, `STYLEGUIDE.md`, and `TESTING.md` files you've already written. It's happening all over again.
So "tu quoque," Claude? My friend Claude, you want me to create an `CLAUDE.md` file because you don't want to read my docs either...
This is why I propose we create an `AGENTS.md` file containing nothing but this:
RTFRA
(Read The Fucking Readme, Agent)

value: Show HN: RTFRA - A Humble Proposal [RFC]


value: Show HN: Capframe – capability tokens for AI agent tool calls


value: happyyeti

value: Show HN: Export Webflow sites and CMS content

author: happyyeti


value: Bender

value: Show HN: The user agents crawling HN today

author: Bender


value: asadawadia

value: Show HN: Building a Programming Language for Myself

author: asadawadia


value: Tidianez

value:
Background on why we built Replay first instead of validation: [ https://dev.to/saferunai/why-we-built-replay-before-everythi... ]
Working SDK in Python and TypeScript. Sub-50ms p95 on the check-action API.
Currently onboarding the first design partners.
Happy to answer questions in the comments.

value: Show HN: SafeRun – Replay debugging and inline prevention for AI agents

author: Tidianez


value: tbreschi

value: Show HN: Javalamp – A glowing terminal screensaver that keeps your Mac awake

author: tbreschi


value: ramayac

value:
A few things kind of aligned over the last month. I'd been wanting to try pi.dev (https://pi.dev), DeepSeek has a very aggressive 75% discount on their v4-pro model until end of May,
and I had this old itch from my LFS days to "do my own thing" with POSIX utilities.
So I set up to do an experimental project with strict architectural rules, pointed an LLM at it, and fed it the BusyBox test suite as ground truth.
The result: 77 POSIX utilities in pure Go, single static binary (~10MB), and it passes 548 of 552 BusyBox tests.
My Honest take: this project is ~90% wiring the AI to do the heavy lifting, ~10% steering it in the right direction. Took about 3 weeks of "prompts" and plans and all that. "Harness engineering" works when you have a solid test suite to validate against, I know, it is an obvious statement, but I have hard evidence now to prove it.
The test suite is the actual hero here, I cannot stress this enough. Without BusyBox's brutally thorough test suite, this project is just random hallucinated code.
Also, I'm not trying to replace BusyBox. It's an experiment. I'm happy with how it went, cheers!

                                                                                Repo: github.com/ramayac/goposix (https://github.com/ramayac/goposix)

value: Show HN: GoPOSIX – a Go-native POSIX userland, ~97% BusyBox-compatible

author: ramayac


value: freakynit

value:
https://npm-supply-chain-attack-techniques.pagey.site/attack...
Website: https://npm-supply-chain-attack-techniques.pagey.site
This covers all techniques used in past 1 year to conduct various attacks on npm packages. Use it to get your project reviewed thoroughly before publishing.
Exploits covered with mitigation information:
1. Maintainer Account Takeover and Malicious Publish
2. Lifecycle Hook Execution
3. Self-Replicating npm Worms
4. CI/CD Identity Plane Attacks
5. Git-Based Dependency Smuggling
6. Remote Dynamic Dependencies
7. Phishing Infrastructure Hosted Through npm and Package CDNs
8. Credential and Secret Harvesting
9. Exfiltration and Dead-Drop Channels
10. Persistence and Anti-Forensics
11. Obfuscation and Payload Packaging
12. Package Naming and Discovery Abuse

value: Show HN: Give This Markdown to Your Coding Agent Before Publishing to NPM

author: freakynit


value: brisbanesilicon

value: As per title. Took a bit of fiddlin' but we got there.

value: Show HN: FpgacapZero on BRS-100-GW1NR9 dev board

author: brisbanesilicon


value: patriceckhart

value: Show HN: Chrome ext to let zot, your terminal coding agent, operate the browser

author: patriceckhart


value: ivoronin

value: Show HN: Paletty – 800 curated terminal themes and a contrast-aware generator

author: ivoronin


value: ishqdehlvi

value: Show HN: Claude Code Bundle for Bug Hunting with 574 Report Patterns

author: ishqdehlvi


value: onexey

value: Just a little fun take on tonnes of new AI apps. It's not meant to be serious. Only for fun and giggles.

value: Show HN: Shitty AI App Idea Generator

author: onexey

title: Show HN: Shitty AI App Idea Generator


value: pixxxel

value: Show HN: Agent thread – Share claude code and codex sessions as public links

author: pixxxel


value: kingofspain

value:
Hello! I've just released Widget Cast today, it's a little app to make looping animated widgets for iOS. Take any video and and you can trim to 10 seconds or less, then apply a load of effects like CRT, night vision, thermal, colour tint, etc - then see it animate away on your home screen.
App store: https://apps.apple.com/gb/app/widget-cast-video-widgets/id67...
Got a glowing futuristic website here too: https://widgetcastapp.com
If you have an Apple watch, you can view them there too.
Could be a special moment or person, or just a dinosaur jumping up & down (which is also special).
It's free with some effects behind IAP (there are sort-of pay-what-you-want tiers). No subscriptions or ads.
Hopefully it's good fun!

value: Show HN: Widget Cast – Video Widgets for Your iPhone and Apple Watch

author: kingofspain


value: nhirschfeld

value: Show HN: Kreuzberg Cloud – ultra fast content intelligence – in public beta

author: nhirschfeld


value: gnusi

value: Show HN: IResearch – C++ search that beat Lucene and Tantivy on their benchmark

author: gnusi


value: zapseo

value:
a few weeks ago, I built professor goose, a socratic ai tutor built around the feynman idea that if you can’t explain it, you don’t understand it. the way professor goose works specifically is you pick a topic, rubber duck at a 3d goose, and instead of answering it asks follow up questions until it understands.
that begs the question, how does the goose know it has understood?
that’s when I thought of an understanding bar - always available to the user to help visualize how much the goose understands you, 0 -> 100%.
the original logic powering the understanding bar went something like this: every turn, id send the convo to an llm and ask it to return a number 0-100 , with a rubric of brackets to make the output less volatile. 0-10 meant no real understanding. 11-20 named , but empty. 21-35 meant a partial understanding, and so on, up to 93-100 for the goose understanding your topic exceptionally. this approach worked. mostly. until I started looking at what came back once real users tested the goose.
two testers were explaining the basic way a cpu works. the first used textbook style definition, (fetch, decode , execute etc) and got a final understanding of 87% after a couple turns. the second used a real world example of a chef, linking it to concepts of a cpu. same level of understanding, expressed differently. the second tester got a score of 36. id built the opposite of what I wanted, a tutor rewarding parroting.
checking into the data to find the source of the variances I noticed if I put the same paragraph verbatim in, and got 5 varying scores out: 51,66,51,70,51. the brackets kind of stabilized the results, but the score was unexplainable. why 66 and not 70? nothing in the system could tell me, the limit just picked.
the fix was to stop adding the model to be the math , and make a new system. now every session gets a ‘flight plan’ when the session has a meaningful topic. a separate llm call generates 3-4 essential subconcepts a real explanation must cover. eg for photosynthesis: what it uses, what it produces, why plants need it. each turn the goose’s evaluator returns discrete depth updates per waypoint (0-3, from not addressed, named, stated, explained in own words), plus any misconceptions which were spotted. Javascript makes sure depth only moves up (like a ratchet), weighted coverage, the gate to finish(wrap) a session, and the flow to repair a misconception.
what if the user introduces a subtopic the the plan didn’t anticipate?
in that case, the system decides whether to amend the plan mid session, with a backfill evaluation to credit prior turns. i also added 5 levels of intelligence to the goose, (breezy to razor sharp) which each make the model judge objective depth, then code decides what’s enough. the same chef analogy now scores 87, because the evaluation prompt explicitly tells the llm the waypoints ideal answer is just a valid framing, not the only one.
to validate these changes, I sat down and acted as 15 different types of users, typing differently explaining differently etc, then made changes based on response and iterated. a little bug I found was the llm evaluator giving credit to the wrong actor - the goose teaching via analogy and the student getting credit for it, fixed that too.
lesson worth keeping: if you build anything an llm needs to rate or rank by number, don’t trust it, give it something discrete, not subjective, otherwise they will fake and hallucinate.
professor goose is live if you want to try it!

value: Show HN: how I fixed my ai goose tutor to stop punishing understanding

author: zapseo


value:
I built this because I was struggling to keep track of my various projects (and personal stuff). I was using a combination of markdown files to keep notes, Google Calendar for reminders and Chrome bookmarks to allow me to quickly get to a project (or its related infrastructure). I was really starting to struggle and found each morning was getting more difficult to get up to speed with what was where and what I needed to work on.
I've used other more complex project management systems and I often found I would get bogged down trying to understand their intricacies. I wanted something simple that I could load up each morning and get started quickly on the important stuff.
So I built Mashari. Originally it was just a list of projects with their todos. Now though, it's evolved into a dashboard which lets you rank your projects by priority, todos that you can shuffle about, a surfacing system that lets you progress on the important stuff without the smaller stuff dropping off your radar, calendar reminders so you don't forget stuff and a simple Wiki for notes. And a simple search system so you can find things.
I'm using Google OAuth because I hate remembering more usernames and passwords. It's built on Rails with Postgres just because it's a solid framework to build stuff quickly and keep things well-structured. I've used other frameworks but I knew I could get this done using Rails without thinking too much or getting bogged down.
There's other stuff as well but I think those are the main things. Oh, Apps, I forgot about those - these let you extend the system - e.g the git App lets you attach a repo so you can see the latest commits.
Anyway, try it out. I'd love the feedback.
You can get me directly on hello@mashari.app
I'm currently adding features as I need them so if you want something just let me know and I'll add it into the queue!

value: Show HN: Mashari – a dashboard to manage your projects


value: Sharanxxxx

value: Show HN: AI Doctor Notes – Private doctor visit notes app for patients

author: Sharanxxxx


value: mazzystar

value: Show HN: I put Codex and Claude in a tank arena; Codex is winning 55% so far

author: mazzystar


value: dansku

value: Show HN: I built a dashboard to combine my WHOOP, Oura and Apple Health data

author: dansku


value: pranshuchittora

value:
GitHub - https://github.com/vostride/agent-qa
Live Demos - https://vostride.com/demo/agent-qa

value: Show HN: Open-Source Agentic QA Harness with Memory

author: pranshuchittora


value: silvertaza

value:
This is a proposal creation and analytics software for small agencies.
Who is it for: a five person web design studio sending a $15K-ish project proposal after a discovery call
I've been long wanting to start building my own businesses, and this is my first true attempt to do so. I've built systems on top of platforms like Airtable and Shopify before, but this is the first time I've attempted to do the thing most people think when they think of SaaS.
Landing site: Astro on Cloudflare Pages
App: React & Cloudflare Workers
Database: Postgres on Railway + Cloudflare Hyperdrive
Misc: Sentry, WorkOS, Paddle, Postmark, Umami, Clarity, Github Actions
This is an extremely cheap setup where I effectively only pay for the domain and the small cost of keeping that Postgres server up. Could've gone for a free service like Neon for my db, but it didn't play well with JDBC in my last project. I enjoy using the Cloudflare stack a lot compared to AWS.
How it differs from other proposal software is the emphasis on design and simplicity. Basically the aim is that you don't need to think about templates, layouts at all. After the discovery call with the client, you can just dump all your thoughts out, let the product take care of this by turning it into a well-reasoned structure that yields an effective proposal that's polished. And once you send it off, you see when it's opened and where the client dwells.
Sample proposal: https://app.proposalkit.io/sample/lumen-studio
You can also sign in and play around in the real thing with user hntest@proposalkit.io with pw hntestproposalkit . It's a shared account though, so expect weirdness, especially WorkOS blocking this kind of use - in any case I can always set you up with a clean account.

value: Show HN: Proposalkit.io – you write the content, we control the design

author: silvertaza


value: ayoubnabil

value: Show HN: Rust Database from Scratch

author: ayoubnabil

title: Show HN: Rust Database from Scratch


value: joebi

value: Show HN: Pay-as-you-play game servers from Discord (£2/mo, four games)

author: joebi


value: ruairidhwm

value: Show HN: Halftrace – See the shape of your agent's failures from your logs

author: ruairidhwm


value: rlipas

value: Show HN: AI-Powered DNA Research Assistant

author: rlipas


value: chrka

value: Show HN: Faster than std:sort and pdqsort

author: chrka


value: jaguarwan

value:
You can play with it here:
https://godbolt.org/z/h4ffsWdq8
The main repo is here:
https://github.com/RaphaelPrevost/ASKL

value: Show HN: A fast, thread-safe C hashmap with lazy sorting

author: jaguarwan


value: NBenkovich

value: Show HN: Agyn, an open-source Kubernetes runtime for AI agents

author: NBenkovich


value: UansaS

value: Show HN: Mathabito – A simple addition and subtraction game for mobile

author: UansaS


value: svett

value: Show HN: One dev environment for humans, CI, and AI agents

author: svett


value: gpattle

value: Show HN: Every Lego minifigure ranked, from over 1.3M user votes

author: gpattle


value: rgombash

value: Show HN: OCL Nexus Local – Open-source local compute fabric for AI agents

author: rgombash


value: sigspec

value:
Browser-based sticker designer for a Zebra LP2844 thermal label printer. I bought an $40 UPS branded LP2844 to print stickers and ended up building this after I couldn't find existing tools that did what I wanted.
GW raster appears to be broken over USB on firmware V4.29, so it prints over serial from a FastAPI backend. More notes on what I ran into are in the README. Image pipeline does XOR compositing, EPX upscale, Otsu/manual threshold, and five dithering algorithms (Bayer 4x4/8x8, Floyd-Steinberg, Atkinson, Riemersma).
Part of this was just an experiment to see if I could use Claude to diagnose the print issues I was running into. Some of the conclusions in the project may be entirely wrong, or entirely specific to my setup. I've arrived at a workflow that works for me but may be based on wrong assumptions. Would love for someone else with an LP2844 to test it out.

value: Show HN: Sticky Icky – a ditherpunk sticker designer for the Zebra LP2844

author: sigspec


value: ticktockten

value: Show HN: DSCode – A VS Code-compatible editor built as a kit of Rust crates

author: ticktockten


value: atkrad

value: Show HN: Synthra – I got tired of gluing config sources together in Go

author: atkrad


value: alshanty

value: Show HN: Free AI headshots from one selfie, no signup

author: alshanty


value: rahilb

value:
Greetings,
I've been meditating for a while; the aim is to have an empty mind for some time. One technique to get rid of an unwanted thought is to allow it to expand to all possible conclusions. This is surprisingly effective. Some thoughts are worth keeping though, so I made a place to put them.
https://turquoisehexagon.co.uk/anima
https://apple.co/4wERObR
AI features are all implemented using on device FoundationModels, CloudKit for backups.
Thanks for your consideration, would appreciate any feedback!
Cheers,
Rahil

value: Show HN: Privacy Focused Voice Journal

author: rahilb

title: Show HN: Privacy Focused Voice Journal


value: qtcapybara

value:
Built it when I got tired of switching tabs and losing context while reading research papers. Gives you AI meaning instantly just by highlighting text and in context of whatever you're reading.
Live on CWS. Would love feedback!

value: Show HN: ContextLens- Highlight any text, get context-relevant meaning instantly

author: qtcapybara


value: jonnyasmar

value:
atrium is a macOS desktop app that provides a fully resumable workspace manager with a variety of heterogenous panes including terminals, browsers, tasks, notes, and more.
Over the last couple of months, I've been building an AI development tool that treats CLI AI dev harnesses as first class citizens. With Claude's SDK pricing changes on the horizon, I wanted to avoid getting locked in to paying API rates for something I already had a subscription for.
It started after my computer crashed and iTerm didn't restore my sessions, so I set out to solve that problem initially. I liked it and added functionality till it became my daily driver. I ended up with atrium and I'm enjoying it so much I thought maybe others would, too.
A little about the principles I started following as I built:
Organization - everything fits into a hierarchy of workspaces, rooms, panes (agents, terminals, browser, notes, source control, etc), and stacks within a highly customizable mosaic.
Persistence - everything, including AI sessions, long-lived processes, rooms, and panes, is saved in real time and restores (and auto-resumes!) in its entirety whether you restart or crash. State is file-based and git backed for extra reliability.
Visibility - sidebars surface detailed agent cards, changes, long-lived processes, and activity. In-app and OS notifications keep you on top of everything.
Control - atrium ships a comprehensive CLI that allows you and agents to drive anything in atrium: open browser panes, spawn other agents, create tasks or notes, or dream up pretty much anything.
It's in early access right now (and I make no guarantees you won't notice) and free to download. All I ask is for feedback :) If you have other solutions to the problems above, I'd love to hear em in the comments!
Download: https://getatrium.dev
Full walkthrough (~22 min): https://www.youtube.com/watch?v=3H7rbn2KFm8

value: Show HN: atrium – a resumable, tiling workspace manager for Claude Code, Codex

author: jonnyasmar


value: philipisik

value:
Hi HN! I'm Philip, one of the founders of Tiptap. Next to our open-source rich text editor framework, we started developing Hocuspocus about five years ago and open-sourced it too, to solve one of our biggest challenges back then: real-time collaboration in web editors. We found Yjs by Kevin Jahns, a CRDT library that handles concurrent edits without conflicts. Basically, Yjs merges changes from users without conflicts and in real-time. Hocuspocus is the WebSocket server built on top of Yjs. It handles real-time sync, presence/awareness, persistence, and Redis-based scaling.
While we use Hocuspocus at Tiptap as the collaboration backend for our cloud services, it also works with any Yjs client (Slate, Quill, Monaco, ProseMirror, or your own setup), and Yjs documents aren't limited to text at all. You can sync any structured data through them, and in the meantime we see projects that rely on Hocuspocus without using the Tiptap editor.
We released Hocuspocus v4 under the MIT license a few weeks ago, and the biggest change is that it's no longer tied to Node. The previous versions depended on the ws package, which meant you couldn't run Hocuspocus on Bun, Deno, or Cloudflare Workers. We moved to crossws, a universal websocket adapter, so the same server now runs on Node, Bun, Deno, Cloudflare Workers, and Node with uWebSockets. That also lets you run collaboration at the edge.
The other changes are smaller but are important if you're using Hocuspocus in production:
1. Every core class and hook payload takes a generic Context type now, so the auth/session shape you build in onAuthenticate flows through every other hook with full type safety (defaults to any so existing code doesn't break).
2. Document updates are now processed sequentially per connection through an internal queue, which fixes a correctness bug where async hooks could cause CRDT updates to apply out of order under load.
3. Transaction origins are structured objects now with a source field instead of raw values and there's an isTransactionOrigin() helper for narrowing.
4. Hook payloads use web-standard Request and Headers instead of Node's IncomingMessage.
5. The wire protocol is backward compatible in both directions, so you can roll out servers and providers independently.
If you want to test Hocuspocus: npm install @hocuspocus/server @hocuspocus/provider
Docs at: https://tiptap.dev/docs/hocuspocus
Source at: https://github.com/ueberdosis/hocuspocus
Because running real-time collaboration on Workers or Durable Objects is new in v4, that's the use case we'd most like to hear your questions and feedback on.

value: Show HN: Hocuspocus 4 – self-hosted Yjs collaboration backend

author: philipisik


value: Show HN: I built an AI cloud architect that ships working infrastructure


value: snakajima

value: Show HN: MulmoClaude – open-source platform where Claude composes tools and GUIs

author: snakajima


value: noahflk

value: Show HN: Google Search Console MCP – read-only, OAuth, free

author: noahflk


value: est

value: commands:<p>/name change name<p>/reset zero the AI context.<p>use `curl -NT. <a href="https://chat.est.im/room_name" rel="nofollow">https://chat.est.im/room_name</a>` for normal chat rooms.

value: Show HN: Chatroom with curl command (requires IPv6)

author: est


value: DhruvKumarJha

value: Show HN: Zero Protocol – A personal context file for AI

author: DhruvKumarJha


value: cleardusk

value:
The model has 3B active parameters. We put the code, homepage, paper and model links here:
- Code: https://github.com/bytedance/Lance
- Homepage: https://lance-project.github.io/
- Paper: https://arxiv.org/abs/2605.18678
- Model: https://huggingface.co/bytedance-research/Lance
p.s. Lance is a research project, not a polished product. The model was trained using fewer than 128 GPUs.

value: Show HN: Lance – image/video generation and understanding in one model

author: cleardusk


value: Show HN: We wrote forensic intelligence reports on 20 open-source codebases


value: Show HN: VibeKeys – a keypad I built for vibe coding


value: tasn

value:
Hey HN, my name is Tom, and I'm excited to share Diom (https://diom.com) - a backend components server.
Diom includes implementations for common backend primitives such as cache, key-value, idempotency, rate-limiting, queues, and streams, with more on the way.
While building Svix, we had to reimplement the same backend primitives that everyone have to reimplement. We also constantly felt the tension between building something custom on top of existing infra (like Redis and Postgres) and adding more dedicated services (like RabbitMQ and Kafka) which we would then need to configure, operate, back up, and maintain. This was even worse for us because Svix is open-source, so additional infrastructure meant additional burden on our customers.
Six months ago we finally decided to build Diom, and focus on developer experience and ease of operation. It's open source, self-contained, and manages its own storage using fjall (a fast LSM-tree-based storage similar to RocksDB). It requires no external runtime dependencies (no redis/postgres/kafka/etc), and supports running as a single node or a highly-available Raft based cluster.
The goal of Diam is to provide developers with the backend primitives they need without having to write custom code on top of Redis, RabbitMQ, Kafka, or even need to run them at all.
It currently supports cache, key-value, idempotency, rate-limiting, queues, and streams. We also plan on adding auth-tokens, distributed settings, feature flags, and other common components; as well as adding more functionality to existing components.
Diom favors ease of operation over scale, so it doesn't match Kafka-level throughput or very high QPS like Redis and Dragonfly. However, most products and developers don't process multiple terabytes and billions of events per second anyway. That said, Diom can still hit high performance for its target use-cases as it implements higher-level primitives rather than basic operations. Additionally, because the primitives live in the same process as the storage, there are fewer network round-trips, which keeps latency low.
It uses HTTP/2 with msgpack as the wire protocol (works fine from browsers), and ships a CLI and SDKs for Python, TypeScript, Rust, Go, and Java, with more on the way.
We have Svix fully ported to Diom and continuously running tests and simulated workloads in one of our staging environments. GA (general availability) is planned for later this year, once we've moved Svix production workloads over.
Repo (MIT licensed): https://github.com/svix/diom
Docs: https://docs.diom.com
Live playground: https://diom.com/playground
I'm excited to finally share Diom, and would love to hear what everyone thinks, and what other components you would like us to build! Would also love help figuring out what to call this. We currently say "component platform," but I'm not a fan of the name.

value: Show HN: Diom – Back end primitives (queue, rate limit, etc.) in one Rust binary

author: tasn


value: discountelf

value:
Hi HN! I’m Zach, co-founder / CTO of Platform Engineering Labs.
We’re building formae, an open-source IaC system that stays in sync with real infrastructure instead of relying on manually maintained state and drift detection. We’ve just shipped Kubernetes, Helm, and Terraform .tfvars support.
The goal with this release was simple: make it easy to start using formae with infrastructure people already have. formae can now discover existing k8s workloads automatically and the ability to utilize existing Helm charts.
Coming from Terraform / OpenTofu and already have variable definitions everywhere? formae now supports consuming values from existing .tfvars files.
You can manage whole k8s clusters - from VMs to workloads - in the same consistent model. Changes made through Terraform, Pulumi, kubectl, or cloud consoles are automatically discovered and synced back into formae.
This release also includes the new public plugin hub, which is now home to our official plugins and, hopefully over time, community-built ones too.
Links:
https://github.com/platform-engineering-labs/formae
https://platform.engineering/
https://blog.platform.engineering/formae-now-comes-with-k8s-...
We’d love feedback from anyone working in platform engineering, DevOps, or SRE.

value: Show HN: Formae now supports Kubernetes, Helm, .tfvars and a public plugin hub

author: discountelf


value:
Hi HN, we share a ton of agent skills at my startup¹ and keeping them in sync was a pain, especially the full cross-product of every team member and every agent they use.
We built Homecrew to solve it for us and open-sourced it. We use it to share skills, make them accessible to every agents, and keep everything in sync.
It works for managing and finding skills outside of your team as well, but its primary motivation was sharing private internal skills.
It's git-based, so if your team has a git repo of skills, Homecrew should "just work".
Hope you find it helpful. Would love any feedback.
¹ https://logic.inc

value: Show HN: Homecrew – Share agent skills across your team and keep them in sync


value: aporce

value: Show HN: Server-side analytics catches AI crawlers and attackers JS misses

author: aporce


value: sirmilesdu

value:
Hey HN, I’m working on Catio, a tool that builds live digital twin diagrams of your AWS infrastructure and includes an AI copilot that can answer questions and reason against that model.
The diagram and chat experience is free to use, read-only, and can be connected to dev or sandbox AWS accounts if you want to try it without touching production. We also have a paid product around AI-generated recommendations and architecture designs, but currently I’m mostly looking for feedback on if this feels useful to you, and how we can improve it!
Happy to answer any questions in thread :)

value: Show HN: Catio - AWS Diagrams and Architecture Copilot

author: sirmilesdu


value: Show HN: Prism Coder – Qwen3.5-14B fine-tuned for MCP tool-routing decisions


value:
It’s well known at this point that documentation needs to be optimized for AI agents - we’re all pointing our Claude Code / Codex / Pi agents at documentation, and expecting the models to figure out how to implement a product.
This, however, changes the entire optimization problem when writing documentation. Good documentation now becomes more objective - you are solving the very concrete problem: can a dumb harness running the dumbest model implement this reliably?
Humans can typically compensate for inconsistent terminology or scattered context across pages, but for agents, this often will waste time (or even just completely confuse the agent).
We’ve been building a small project around this called dari-docs: users can upload their documentation via website or CLI and run agents across different providers to see where they falter. You can upload your documentation, feed a list of tasks, and ask agents with varying intelligence / cost levels to complete those tasks in parallel. When a run is complete, you get back a list feedback markdown files from each agent run and can apply changes based on agent feedback.
Managed service: https://optimize.dari.dev/, repo link: https://github.com/mupt-ai/dari-docs
The agents actually try to use the product end-to-end. They search through the docs, follow instructions, run commands, try examples, and attempt to debug failures. Importantly, this is not a static LLM review of the documentation. The agents are actually attempting the integration.
You can also enable live verification with test credentials so the agents can actually verify workflows against real APIs:

  dari-docs check . --live-verify --secret-env DARI_TEST_API_KEY --task "Create a checkout session"

If you’re building a CLI, API, MCP server, or SDK and actively maintaining docs for humans or agents, we’d love to work with you and test this on real workflows!

value: Show HN: Dari-docs – Optimize your docs using parallel coding agents


value: ddayanov

value: Show HN: IgniteMS – batch text embeddings at 253K msg/s on 8x A100

author: ddayanov


value: anonfunction

value: Show HN: Headless terminal in zig allows AI agents to use interactive CLIs

author: anonfunction


value: roynal

value: Show HN: Sentience – governance that carries across AI agent sessions

author: roynal


value: morland

value:
I'd seen various HN trends tools over the years ([1] [2]), but they all used strict keyword (n-gram) matching. That limited a) how sophisticated any trend-surfacing could be and b) the depth with which you could explore the full discussion around any topic. How can you tell what people are saying about, e.g., agentic coding when you have to search for a dozen applicable keywords at once?
So I built p-Hacker, which uses a ML pipeline to cluster the HN corpus into distinct topics and spot current trends beyond simple keyword frequencies (though it does that, too). You can search for full topics or simple keywords, and compare them side-by-side.
I started off running it on my laptop just to work out the mechanics, but after lots of iteration thought maybe I should put it online publicly. There's lots of room for improvement (the data only goes back about two years, nightly updates take a couple of hours, item topic membership could be improved).
Feedback welcome.
[1] https://news.ycombinator.com/item?id=22233457
[2] https://hntrends.net/

value: Show HN: P-Hacker – group/analyze HN trends by topic (not just keywords)

author: morland


value: hmg-ocean

value: I built this fun visualizer to show how much physical commodity bitcoin buys. I've launched with gold, silver, Plutonium-238, and one other substance that’ll never get a ticker symbol. And there's a dog for scale. It's all client-side math, open data, SvelteKit + Three.js. Click the Satoshi, Strategy, and US Govt presets to see what each stack buys, slide the slider all the way from 1 sat to 21 million bitcoin, turn on the Geiger counter when you find it.

value: Show HN: How much gold, silver, or Plutonium-238 does 1 BTC buy?

author: hmg-ocean


value: patrickmds

value:
Hi - I'm Patrick. Did YC in S22 + Revolut, Nubank alum.
Trainy is made for you to learn how to build AI products, without being fired in real life.
It seems like every company in the world wants to use AI (for whatever reason). At the same time, 95% of their workforce has no clue how to do it. Plus, AI jobs are the hottest right now but talent is scarce. So basically, everyone needs to up-skill.
I'm not an ML engineer so struggled to learn how to build an AI product. Took me months and a bunch of mistakes. So I decided to try to fix it.
Trainy is a simulator to replicate the experience of building an AI product from within a large company. You interact with agents representing CEOs, CTOs, Compliance, etc who have their own expertise, way of looking at things and even personalities. If you screw up the CEO will actually fire you.
The full simulator is still being built but on this link you can experience a few scenarios. Would love to hear what you think feels off about the interaction.

value: Show HN: Trainy, an AI team that fires you

author: patrickmds


value: aleshh

value:
This started out when I vibe-coded a guitar scale fingering generator. It came out pretty good, and I started adding stuff to it: chords, then how chords and scales interact.
Then I added charts for other instruments I mess around with: piano, cello, alto recorder.
There's a complexity toggle to go from basic harmony to extended/experimental stuff.
It's honestly still mostly a toy, but I thought other people might be interested in playing with it. Source is on github, so it's easy enough to run locally and fork.
https://github.com/aleshh/gtr-scales

value: Show HN: I made a tool for learning scales, chords, and how to combine them

author: aleshh


value: muthuishere

value: Show HN: Llama CPU Benchmarks

author: muthuishere

title: Show HN: Llama CPU Benchmarks


value: mfairley

value: I built an expo-module that makes it easy to integrate CallKit/Core-Telecom into a React Native app. I've built a VoIP app before and this was one of the hardest parts. The existing react-native-callkeep is harder to use, isn't easy to set up VoIP notifications with and hasn't been updated in two years. This new module is tested with the latest versions of iOS/Android, Expo and LiveKit. It has a simple and unified API across iOS/Android.

value: Show HN: expo-callkit-telecom – easily integrate CallKit/Core-Telecom

author: mfairley