Show HN for July 24, 2025

Hi HN, I’m Arlan, and I built Nia (https://www.trynia.ai), an open MCP that integrates with coding agents like Cursor, Continue, and Cline so they can retrieve external knowledge better than current approaches.

Coding agents generate code well but lose accuracy when the answer lives outside the repo in front of them. Developers end up pasting GitHub links, docs, and blog posts by hand and hoping the agent scrolls far enough. Long context windows help, but recent “context rot” measurements show quality still drops as prompts grow. For example, in LongMemEval, all models scored much higher on focused (short, relevant) prompts (~300 tokens) than on full (irrelevant, 113k tokens) prompts, with performance gaps persisting even in the latest models (https://research.trychroma.com/context-rot).

Nia is a MCP that gives more context to any coding agent or IDE. It Indexes multiple repos and docs sites and makes this available via MCP to your coding agent so it has much more context to work with, giving you more specific and accurate answers.

Nia uses a hybrid code search architecture that combines graph-based structural reasoning with vector-based understanding. When a repo or documentation is ingested, Tree-sitter parses it into ASTs across 50+ languages and natural languages, and the code is chunked by function/class boundaries into stable, content-addressable units. These chunks are stored both in a graph db to model relationships like function calls and class inheritance, and in a vector store. At query time, a lightweight agent with give_weight tool dynamically assigns weights between graph and vector search based on intent (e.g., "who calls X" vs "how does auth work"), and both paths are searched in parallel. Results are fused, enriched with full code context, and passed through multi-stage rerankers: semantic reranker, cross-encoders, LLM-based validators.

Early Signal: In internal evals we improved Cursor’s performance by 27 % once Nia had indexed external docs models couldn’t get from their training data or searching the web.

Quickstart: <https://www.youtube.com/watch?v=5019k3Bi8Wo> Demo: <https://www.youtube.com/watch?v=Y-cLJ4N-GDQ>

To try it out: grab an API key at https://app.trynia.ai/ and follow instructions at https://docs.trynia.ai/integrations/nia-mcp.

Try it and break it! I’d love to know which contexts your agent still misses. Corner cases, latency issues, scaling bugs. I’m here 24/7.

Thanks!

When the startup I was working for shut down, I knew it would probably be a while before my health allowed me to commit to a new role, so I decided to start working on some personal projects to keep my mind active and engaged.

With AI-augmented VS Code forks being all the rage at the time, I wanted to take a slightly different angle on a code editor/viewer using the same core technology. That led me to building Tachi Code, a Monaco-based code editor that integrates directly into your browser as an extension to streamline your more ephemeral coding tasks, so you can spend less time switching between your code editor and browser.

The original flow that piqued my interest was viewing raw source files or API responses. Historically, I've used a JSON formatter extension to prettify JSON, but I wanted something more powerful, more universal, and quite frankly, something that looked better, so I built Tachi Code with the ability to detect when you're viewing pre-formatted text and inject itself into the page, so it's always beautifully syntax highlighted, foldable, and regex searchable. Then I added context menu integrations, so you could quickly edit snippets, compare text, or view the current page's source in Tachi Code's editor.

The browser extension works offline with the only external HTTP requests going to GitHub to retrieve JSON Schemas or additional themes. All user data stays local. The only tracking is CloudFlare's web analytics beacon on TachiCode.dev (not present in the browser extension or in the EU).

TachiCode.dev is a sandbox environment that serves the latest commit of Tachi Code's editor hosted on CloudFlare Pages.

The core stack is: - React 19 - Monaco Editor - Radix UI - Zustand - Shiki - WXT (full SBOM is available via the about dialog if you want to dig deeper)

Monaco Editor provides the code and diff editors, as well as low level systems for configuration and theming. There's a lot of hackery involved in surfacing those systems and integrating them into the larger React app. Shiki is used to provide more complete syntax highlighting than Monaco Editor provides out of the box. The rest of the UI is primarily based on Radix UI components, typically starting from a shadcn template and then reworked to use colors provided by the theme system. Zustand is my go-to for any kind of shared/persistent state. WXT just turns browser extension development and publishing into a breeze.

If you've got any feedback or a question about how the app was developed, I'd love to hear it!

Hi HN! Stefan here from superglue and today I’d like to share a new benchmark we’ve just open sourced: an Agent-API Benchmark, in which we test how well LLMs handle APIs.

We gave LLMs API documentation and asked them to write code that makes actual API calls. Things like "create a Stripe customer" or "send a Slack message". We're not testing if they can use SDKs; we're testing if they can write raw HTTP requests (with proper auth, headers, body formatting) that actually work when executed against real API endpoints and can extract relevant information from that response.

tl:dr: LLMs suck at writing code to use APIs.

We ran 630 integration tests across 21 common APIs (Stripe, Slack, GitHub, etc.) using 6 different LLMs. Here are our key findings:

- Best general LLM: 68% success rate. That's 1 in 3 API calls failing, which most would agree isn’t viable in production

- Our integration layer scored a 91% success rate, showing us that just throwing bigger/better LLMs at the problem won't solve it.

- Only 6 out of 21 APIs worked 100% of the time, every other API had failures.

- Anthropic’s models are significantly better at building API integrations than other providers.

Here is the results chart: https://superglue.ai/files/performance.png

What made LLMs fail:

- Lack of context (LLMs are just not great at understanding what API endpoints exist and what they do, even if you give them documentation which we did)

- Multi-step workflows (chaining API calls)

- Complex API design: APIs like Square, PostHog, Asana (Forcing project selection among other things trips llms over)

We've open-sourced the benchmark so you can test any API and see where it ranks: https://github.com/superglue-ai/superglue/tree/main/packages...

Check out the repo, consider giving it a star, or see the full ranking at https://superglue.ai/api-ranking/.

If you're building agents that need reliable API access, we'd love to hear your approach, or you can try our integration layer at superglue.ai.

Next up: benchmarking MCP.

The AI Horseless Carriages article spurred a lot of conversation about how we should just be giving users the system prompt box [0], and we were pretty surprised that a bunch of email clients didn’t pop up following this pattern [1].

So we went ahead and created a local [2] email client that you can run that processes your inbox with your own handwritten rules. It lets you label and archive based on natural language rules. You can draft responses with your own drafting prompt, and there’s a “research sender” option that uses web search to get public info on a sender. You can customize any of the prompts to fit your needs. We’d love to hear what you think and PRs/issues are welcome!

[0] https://news.ycombinator.com/item?id=43773813 [1] Superhuman seems to be pulling on this thread [2] uses OpenAI for this version, client runs locally, ollama support soon!

Hi HN!

We are a small team that has been bootstrapping an AI‑native solution to help B2B companies capture hidden buyers by automating the identification, research, and qualification of anonymous website visitors with just one line of code.

Here is a quick product video: https://youtu.be/ptGYkWbCJN4?si=hLvZGVbYMYbxzNwg

Four of our five team members hold PhDs in statistical inference or related fields, and we came together because we believe that modern GTM tools excel at collecting signals but fall short on the inference layer. Simply plugging an LLM into a dashboard won’t cut it – the real breakthrough requires a far sharper lens and far stronger predictive engines than legacy platforms provide. That’s exactly what we’re building.

The current version of Watchman transforms anonymous web traffic into pipelines of qualified accounts and person‑level leads. Our agent identifies, researches, and qualifies anonymous visitors, syncs those enriched leads into tools like HubSpot and Salesforce, sends live notifications to Slack and email, and supports unlimited users so you can invite your entire team.

We’d love for you to try it out and share your feedback! Check it out at https://joinwatchman.com

Over the last 3 weeks, I built a website to organize 70+ AI tools into a searchable, reviewed, and categorized hub.

Use case: I was constantly sharing AI tools with friends & colleagues, but the available directories felt outdated, shallow, or spammy.

So I built my own:

- Tools are categorized (e.g. writing, voice, code, automation) - Marked clearly as free/paid - Includes brief reviews, ROI notes, and usage tips - Fully searchable and updated daily - Working on tool ratings, comparisons, and a “trending” leaderboard

Website: https://www.toolsverse.tools/

I’d love feedback and suggestions — and maybe more tools to add.

Thanks for reading!

I have worked with AI assistants for a while, and while I am really excited about it, there were times when I felt really frustrated. LLM would end up in a loop with no end.

This is when I started experimenting with creating work plans. Initially simple todo list, but it felt like "product vibing", so a bit more sophisticated later on. I started seeing value in it.

The one day it hit me. Why not use the same GitOps principles to managing product tickets? I started playing with that and really liked the way it worked.

After a chat with a friend of mine, I realised that a standard or a spec would be something really useful. You could then create all sort of tooling around this.

I took an inspiration from the way kubernetes yaml are used, cause I find it quite neat.

You can view examples here: https://spec.productascode.org/draft/#sec-Epic-Example-YAML-

Key design decisions so far:

1. YAML over JSON: Human-readable, git-diff friendly, excellent tooling ecosystem 2. Hierarchical structure: Epics → Tickets → Tasks (matches development workflow) 3. Atomic tickets: Each ticket = one branch = one PR (prevents scope creep) 4. ISO 8601 timestamps/durations: Machine-parseable time data

If I manage to create an epic with a bunch of tickets in backlog, then my favourite part of work is to tell Claude Code: "Close the current ticket, and start another one".

Here is the link to the post which has links to draft spec and GitHub repository.

Currently working on v0.1.0 and I would love to hear your thoughts.

https://mantcz.com/blog/introducing-product-as-code/

There are many commercial YouTube summarizers, but I couldn't find an open-source one that truly fit my needs. So, I built YouTubeTLDR: a simple, self-hostable solution that uses the Gemini API without much bloat.

I went with a synchronous approach + threading which was a nice break from Tokio.

It is Bring Your Own Key, but the key is sent to the server for each request, which is something I might revise in the future.

There is a demo on https://youtubetldr.onrender.com/

At its core, the $350B resale industry is a messy, unstructured data problem.

Resale isn’t a single market — it’s an extremely fragmented ecosystem of global marketplaces (The RealReal, Poshmark, Etsy, eBay, Fashionphile, etc.) and a long tail of independent resellers, social media merchants, and vintage/consignment shops.

On both the consumer and enterprise sides, the biggest pain points stem from a lack of unified product schemas and inconsistent condition nomenclature and evaluation standards.

We’re building SECONDSENSE to be the operating system for luxury resale, and we just launched our new UI to empower shoppers with data to find the best deals & investment pieces.

Would love feedback from anyone who’s worked on marketplace data, product search, or catalog infrastructure.

For years, the question of my actual 'body count' was a nagging personal curiosity. My memory is fallible, and the common solutions—like keeping a list in a notes app or a spreadsheet—always felt insecure and strangely clinical. I wanted a tool built for this specific purpose: a private, secure space to finally get an accurate number.

So, I built BodyCount.

Once I started inputting my own data (the data my brain had long forgotten), the project evolved. It became less about the final sum and more about the story the data told. Visualizing the connections on a map and seeing patterns over time gave me a new perspective on my own history. It wasn't just a number; it was a private, personal dataset that I owned and controlled.

From a technical standpoint, privacy was the absolute priority. The goal was to create a space that felt significantly more secure than a standard cloud-based note. All data is stored privately, with a focus on ensuring user entries are for their eyes only.

I posted an earlier version here a couple of days ago and received some great feedback. A recurring theme was the desire for people to try it out without hitting a paywall. So, I've spent the last 48 hours implementing a freemium model. You can now log your first few connections and explore all the features for free to see if it's right for you.

The site is www.bodycount.love

I’d love to get your feedback on the new freemium flow and the overall concept. Is a private, data-driven dashboard a better solution than the old notes app method for this kind of personal data?

gencmd is an open source, interactive command line utility to generate bash commands from a natural language description, directly from the console.

marchat is a terminal-first, real-time group chat application written in Go with a Bubble Tea UI and WebSocket backend.

It’s designed to be lightweight, self-hostable, and usable entirely from the terminal.

Features: - Group chat with theming - JSON-based configuration - File sharing - Admin tools

Still in beta, looking for early feedback and contributors: https://github.com/Cod-e-Codes/marchat

I used to queue 6 hrs on a 4090 just to get dialogue that still floated half a second late. Last week I swapped the entire pipeline for Google’s Veo 3 running behind a 6-line FastAPI wrapper; now the same 30-second spot drops in 18 s with 99 % mouth-match accuracy. No timeline, no keyframes—just text → mp4 with synced sfx baked in. Benchmark repo and the wrapper are MIT on GitHub, plug your key and roast my latency numbers. Live demo at https://veo-3.app/

contact - [email protected]

Hi HN,

I’ve been tinkering with ultra‑simple blockchain games and built ETHShot.io, a tiny dApp where each “shot” at a jackpot costs 0.0005 test‑ETH and has a 1 % chance to win the whole pot. It’s live only on the Sepolia/Goerli testnets, so no real ETH is involved.

How it works

- Connect a testnet wallet (MetaMask, Rabby, etc.).

- Each transaction (“shot”) sends 0.0005 test‑ETH to the contract.

- On every shot there’s exactly a 1 % chance the contract pays the entire pot to the sender.

- Non‑winning shots add to the pot minus a small maintenance fee. 0 Contract is under 80 lines of Solidity; front‑end is plain Svelte. Source code: https://github.com/profullstack/ethshot-web.

I’m looking for feedback on

- Usability and onboarding (is the flow obvious?).

- Contract design, gas savings, and any attack surface you spot.

- Whether the 1 % odds feel right or should be dynamic.

Quick start

- Grab a little test‑ETH from any Sepolia faucet.

- Visit https://ethshot.io and take a shot.

- If you win, you’ll see the transaction immediately; if not, you’ll see the pot grow.

- Bug reports and ideas welcome here or as GitHub issues.

Thanks for taking a look.

— Anthony (cranberryturkey)

Hi HN,

I created this Chrome extension, doomlingo.com, to help people learn foreign languages while browsing their Twitter/X feed. The idea is simple: the extension converts all of your Twitter content from English to one of the five currently supported languages: Italian/French/Spanish/ German/Portuguese and you have to understand the message by translating the text. The extension provides a simple, fast UI to help with that.

So, if you want to get your daily dose of dopamine, you'll have to work for it. My hope is that my craving for the daily Twitter feed will be strong enough to motivate me to go through the struggle of translating and understanding foreign text. But that remains to be seen and may vary from person to person. The opposite might also happen: you may not want to use Twitter anymore because it's simply too much work.

You can download the extension from the Chrome Web Store. Unfortunately, you’ll have to register to try it because I’m using an LLM to translate the Twitter feed in real-time, and I need to rate-limit users to avoid DDoSing my API. As a free user, you get a certain number of translation tokens per month. Beyond that, it’s a paid membership, since the LLM translation service I use is not free.

Would like to hear your thoughts and feedback on this, thanks all.

I love the niche social media of Strava. Use it as a personal log of your own exercise and/or a light-touch way to keep track of friends lives. Cooking is something we do 3+ times per week like exercise so I built this. I wrote 0 lines of code (not a programmer, just a lowly PM) and graduated form lovable to cursor to Claude code. All feedback welcome :)

My fingers have been aching lately, likely due to inflammation, and I have an important project I need to work on, but haven't been able to put in the time it needs.

I tried the various speech-to-text products out there like WisprFlow and VS Code Speech but they both did a pretty lousy job of converting my speech to code syntax.

I put together this VSCode extension that works very well for my needs, which is dictating code syntax orally and converting it to the right code, based on the context on the page.

So if you have

type User struct {

   ID        string    `json:"uuid" gorm:"primaryKey;type:uuid"`

   | <- cursor here

}

You can say outloud:

"Updated at time dot time json updated at not null"

and it will convert it to:

type User struct {

   ID        string    `json:"uuid" gorm:"primaryKey;type:uuid"`

   UpdatedAt time.Time `json:"UpdatedAt" gorm:"not null"`

}

Demo video: https://x.com/moughxyz/status/1948477448838152259

Direct download link: https://marketplace.visualstudio.com/items?itemName=moughxyz...

Hi HN,

We’re the team behind Rejoy Health, an AI search engine built specifically for doctors. We launched it to solve a frustrating but critical problem: Clinicians spend too much time searching through dense PDFs, outdated databases, and fragmented resources to find reliable answers to clinical questions, especially at the point of care.

With a new medical paper published every ~30 seconds, it’s impossible to keep up. Rejoy lets doctors ask questions in plain language (e.g. “How do I manage atrial fibrillation in elderly patients?”) and get trusted, evidence-based answers with linked sources in seconds.

Think of it as a conversational interface(ChatGPT for doctors)to the medical literature, with citation transparency built in.

We're not trying to replace doctors or provide medical advice to patients, just reduce cognitive load and help them move faster with information they can trust.

Some quick points:

* Trained and tuned specifically on high quality, peer reviewed medical content

* Used by 50,000+ physicians so far

* Enterprise deployments support on-prem or VPC, for health systems that need full control

We’re focused heavily on verifiability (everything is sourced) and safety (reliable fallback answers > hallucinated ones)

Would love your feedback on everything—from the retrieval stack to deployment, use cases, and UX. Happy to answer questions about how we built it or how clinicians are actually using it day to day.

https://www.rejoyhealth.com

Thanks!

Rejoy Health Team

Hi again HN.

The short version: a retro style computer simulator, focused on low-level coding. You could sort of think of it as pico8's low-level stuff (peek/poke, memory access, vram, etc) turned up 1000%.

For example, it gives you a Lua API for encoding assembly to memory and then running it, and you can access the same memory space from Lua as from Assembly. It uses your native assembly btw, it's not a custom assembly language, it's real 64-bit windows assembly.

It also comes with LPeg built in, so that you can experiment with generating either Lua bytecode or native assembly, making it a really fun and visual way to make your own programming language! It's really nice to be able to write your own code that literally draws to the screen. Imagine making your own language and making pong work in it!

It's still very early, but last time I posted here I was told to release early and release often, so I'm putting a lot of the really exciting features into the next few releases.

Thanks for your time, have a great day!

Hello HN, I am a policy person who is often found reading papers. I built this app to curate papers that have piqued my interests to share them with wider audience. One thing that I have repeatedly heard academics say is that no one reads their research.

So I thought may be this is one way to consume for everyone that I genuinely find beautiful: answers to really important questions.

As I read this particular paper, for example, I kept thinking, how big our productivity gains shall be if we could improve education in the more underprivileged areas of the world.

I hope you like it as much I loved reading it!

Paper link here too: https://www.nber.org/papers/w24062

A static web server based on NodeJS. It could be used as folder explorer.

I built Team Toggle to solve my own team's annual leave struggles - looking for feedback!

As a developer who also manages a team, I got fed up with the email chains and error-prone Excel spreadsheets for tracking annual leave. The process was time consuming. People would email requests, I'd update a spreadsheet, then someone would book time off that conflicted because they were looking at an outdated version. The lack of visibility was the killer - nobody could easily see who was out when. It's just a faff.

Yeah I know there are existing products for this, and big HR and payroll software usually has modules to cover it but I'm a developer and I like building things. So I built Team Toggle as a side project over the past year, just evenings and weekends now and then. It handles leave requests, approvals, shared calendar views, and lets you set custom policies for your team.

Technical side:

I used .NET 8 MVC with MS SQL Server - pretty straightforward stack for a line-of-business application. The actual development was the easy part for me since I've built similar internal tools before. The real challenge has been everything else: marketing, landing page optimisation, figuring out how to get people to actually find and try the tool.

Where I'm at:

The users I do have really like how straightforward it is to use, and I've been able to be very responsive to feature requests. But I'm struggling with the typical developer problem - I can build the thing, but I'm not sure I'm selling it effectively.

What I'm looking for:

I'd love brutal feedback on whether my landing page does a good job explaining the value proposition, whether the product itself seems compelling enough, and any advice on getting traction. I'm particularly interested in hearing from anyone who manages teams or has dealt with PTO and annual leave tracking tools - does this solve a real problem worth paying for?

Feel free to be as blunt as possible. I'd rather get honest feedback now than keep spinning my wheels.

Homepage: https://teamtoggle.com

Hi HN,

My co-founder and I are launching LightLayer next Monday (July 28) — a voice-first AI code review platform that helps engineers review code 5x faster.

Since starting to use tools like Cursor / Claude Code, we found that writing code is no longer the bottleneck. Reviewing and understanding it is. AI can write the code, but it’s not making it to prod without a human-in-the-loop (unless your team fuels on chaos and stale coffee).

Introducing LightLayer, a voice-native code review platform that emulates walking through the PR with the author. Get questions answered and comments drafted in real time as you talk. Free (forever) for open-source teams and lifetime-discounted for early beta teams.

We use LightLayer to build LightLayer and can’t imagine switching back to regular code reviews.

We're looking for open source contributors to join the beta and help shape the product. If you're excited about AI + devtools, voice UX, or fixing code review — we’d love to hear from you.

Site: https://lightlayer.dev (sign up on the site)

Or just email me to join (or if you have any questions): [email protected]

G’day HN, this year I've been remaking my online adaption of the classic party game 1000 Blank White Cards (https://en.wikipedia.org/wiki/1000_Blank_White_Cards)

I started this project in 2019/2020, originally as a drinking game for house parties, but it transformed into a way for my friends to keep in touch during the long Melbourne COVID lockdowns.

Essentially anyone can draw and submit cards to a common ‘Global Deck’. You then pick them up and do what they say (or not). The whole premise of this game is that there are no concrete rules - they’re forever evolving.

Over the years people from around the world have contributed nearly 500 cards. I have to say I’m impressed that it’s probably 80% high vs 20% low quality content. The art ranges from awesome to hilariously crude and the gameplay is somewhat coherent - but always hilarious.

There are global servers for multiplayer custom games where people can jump into the same session and move cards around a bit more like a real tabletop game. I’ve recently added support for Discord Activities (https://discord.com/discovery/applications/13895086247742013...) so you can play directly inside a call.

Start with a blank slate and save your custom deck creations to re-upload in later games. Coming up on the feature roadmap is a proper deck builder/editor mode.

It’s been a really interesting challenge trying to create a game that has no rules, but I’ve learnt a lot in the process. My biggest takeaway is that human creativity has no (lower) bound :)

I hope you have as much fun playing it as I do making it, and that one day we’ll reach the magical 1000 card mark.

~mcteamster

P.S. this wouldn't have been possible without great open source software like + https://boardgame.io/ + https://wiredjs.com/ + https://www.fiala.space/atrament/ = https://github.com/mcteamster/white

I have to edit pretty long pipelines really often, and doing so right in shell prompt isn't always convenient. What you get by using this tool:

* stage outputs are cached, so costly API call or SQL query are executed just once (of course, they are restarted if command changes) * preview of any stage output * it is possible to integrate it with shell to edit existing pipeline and get updated pipeline back in command line * copy any command or any stage output to clipboard

There are rough edges too:

* there is no scrolling right now * editor is pretty limited

To overcome these limitations there are keys to call you favorite pager and editor.