Show stories

I built a macOS menu bar app to track Claude usage in real time via API after hitting limits mid-flow too often.

Signed and notarised by Apple. Open source.

https://github.com/richhickson/claudecodeusage

https://x.com/richhickson

My name is Adrian. I'm a Software Engineer and I spent 6 years developing a perimeter-based geofence-based social media app.

What it does:

- Allows you to load a custom perimeter anywhere on the geographic map (180° E and W longitude and 90° N and S latitude), to cover area any area of interest

- Chat rooms get loaded within the perimeter

- You can chat with people within the perimeter

I developed a mobile app that uses an advanced geofence-based networking system from 2013 to 2019. My goal was to connect uses within polygon geofences anywhere in the world. The app is capable of loading millions of polygon geofences anywhere in the world.

https://enterpriseandroidfoundation.com/assets/images/other/...

But people didn't really have a need for this. So after failing, I spent the next 6 years trying to ideas to use FencedIn for. I tried a location-based video app and a place-based app that had multiple features. Nothing worked, but now I'm almost finished developing ChatLocal, an app that allows you to load a perimeter anywhere on the geographic map, which loads chat rooms.

The tech stack is 100% Java (low-level mostly). I have a backend, commons library and an Android app. Java was the natural choice back in 2013. However, I still wouldn't choose anything else today. Java is the best for long-term large-scale projects. (I'm also using WildFly. PostgreSQL and a Linux server.)

This app is still not fully finished, but I think the impact on society might be tremendous.

The previous app to ChatLocal, LocalVideo, is fully up on the Google Play store and can be tested. It has 88% of the features of ChatLocal, including especially the perimeter-based loading system.

The feedback I'm mostly looking for is new ideas and concepts to add to this location-based social media app. And how strong of a value proposition does the app have for society.

I forked a PyTorch DeepDream implementation and added video support with temporal consistency. It produces smooth DeepDream videos with minimal flickering, and is highly flexible including many parameters and supports multiple pretrained image classifiers including GoogLeNet. Check out the repo for sample videos! Features:

- Optical flow warps previous hallucinations into the current frame

- Occlusion masking prevents ghosting and hallucination transfer when objects move

- Advanced parameters (layers, octaves, iterations) still work

- Works on GPU, CPU, and Apple Silicon

Hey everyone, I made this thing: https://tryflux.ai/

Context: I've tried probably 15 different AI apps over the past year. ChatGPT, note-taking apps, productivity apps, all of it. But most of them are just clutter on my iphone.

They live in some app I have to deliberately open. And I just... don't. But you know what I open 50 times a day without thinking? iMessage. So out of mild frustration with the "AI app graveyard" on my phone, I built Flux.

What it does: - You describe a personality and what you want the agent to do - In about 2 minutes, you have a live AI agent in iMessage - Blue bars. Native. No app download for whoever texts it.

The thesis that got us here: AI is already smart enough. The bottleneck is interaction. Dashboards get forgotten. Texts get answered.

This was also my first time hitting #1 on Product Hunt, which was surreal.

We're very early and probably broke something. If you try it, feedback is super welcome, weird edge cases, "this doesn't work," or "why would anyone use this" comments all help.

That's all. Happy to answer questions.

My agency was bleeding $1,800/year on contractor Notion seats. The problem: I needed to give contractors access to specific data (CRM, project tracker) but couldn't let them see pricing, margins, or other clients' information.

Notion's native solution doesn't work:

Row-level filtering exists but it's view-only (contractors can't edit)

Column hiding doesn't exist

Guest sharing is read-only

So you either pay $15/mo per seat or duplicate databases (maintenance nightmare)

I built a permissions layer using Notion's OAuth API. It lets contractors see only specific rows and columns, edit data, all without expensive seats.

How it works:

Connect Notion via OAuth

Define roles: "Sales reps see only leads where owner = them, hide pricing column"

Contractors access a clean portal

They view/edit data in real-time (syncs every 5 minutes)

You pay $59/mo flat for unlimited users

The math:

5 contractors × $15/mo = $900/year wasted

20 contractors × $15/mo = $3,600/year wasted

50 contractors × $15/mo = $9,000/year wasted

With this: all of them = $59/mo flat.

Technical:

Frontend: React + TypeScript

Backend: Supabase + PostgreSQL (RLS)

Auth: Notion OAuth 2.0

Current state: 50 beta testers. First 20 customers get $49/month locked-in (launching at $79 after January).

Limitations:

Only Notion databases (not pages)

5-minute sync (not instant)

Requires role definition

No team permissions yet (roadmap)

The ask: If this solves a problem you have, we'd love feedback. Are there permission use cases we're missing? What's your price sensitivity?

Free trial: notionportals.com

Remotedays helps companies maintain compliance with EU cross-border remote work regulations. When employees work remotely across borders (France, Belgium, Germany, Luxembourg), exceeding specific thresholds triggers social security and tax liability shifts for both employees and employers.

Thresholds:

France/Belgium: 34 days/year Germany: 183 days/year

Most companies track this manually or not at all, creating audit and penalty risk.

Key Features

For Employees:

One-click daily declarations via automated email prompts with real-time threshold tracking

For HR/Compliance:

Real-time compliance dashboard with alerts across the entire workforce

Complete audit trail for regulatory inspections

Links

Live: https://remotedays.app

Demo: https://demo.remotedays.app

Built with security and GDPR compliance as core requirements. Currently seeking feedback and open to customization or developing similar compliance solutions for specific organizational needs.

Questions and feedback welcome.

Personabox is a web application that allows users to create, manage, and switch between different digital personas or identities. It aims to help users maintain separate digital identities for different aspects of their lives, such as work, personal, or online activities.

Each moving arrow represents one real bike ride out of 291 million, and if you've ever taken a Citi Bike before, you are included in this massive visualization!

You can search for your ride using Cmd + K and your Citi Bike receipt, which should give you the time of your ride and start/end station.

Everything is open source: https://github.com/freemanjiang/bikemap

Some technical details: - No backend! Processed data is stored in parquet files on a Cloudflare CDN, and queried directly by DuckDB WASM

- deck.gl w/ Mapbox for GPU-accelerated rendering of thousands of concurrent animated bikes

- Web Workers decode polyline routes and do as much precomputation as possible off the main thread

- Since only (start, end) station pairs are provided, routes are generated by querying OSRM for the shortest path between all 2,400+ station pairs

PokerBench is my attempt at a new LLM benchmark wherein frontier models play Texas Hold'em in an arena setting. It also features a simulator to view individual games and observe how the different models reason about poker strategy. Opus/Haiku, Gemini Pro/Flash, GPT-5.2/5 mini, and Grok 4.1 Fast Reasoning have all been included.

All code -> https://github.com/JoeAzar/pokerbench

Hi HN — I built Catnip, an open-source iOS app that lets you run Claude Code against a real development environment from your phone.

Under the hood it spins up a GitHub Codespace, installs Claude Code, and connects the iOS client to it securely. You can use a full terminal when needed, or a lightweight native UI for monitoring and interaction.

I built this because Claude Code is most useful when it has access to a persistent environment with plugins, tools, and real repos — and I wanted that flexibility away from my laptop.

GitHub gives personal users 120 free Codespaces hours/month, and Catnip automatically shuts down inactive instances.

Open source: https://github.com/wandb/catnip App Store: https://apps.apple.com/us/app/w-b-catnip/id6755161660

Happy to answer questions or hear feedback.

The article discusses the author's experience of designing an overly complex Dungeons & Dragons character sheet, highlighting the balance between functionality and simplicity in game design and application development.

This idea has been floating in my head for about 10 years. Some of you might remember LowEndSpirit.com back before it became a forum, I started that. I've been obsessed with making tiny, cheap VPS actually useful ever since.

TierHive is my attempt to make 128MB VPS great again :)

It's a NAT VPS (KVM) platform with true hourly billing. Spin up a server, use it for 3 hours, delete it, pay for 3 hours. No monthly commitments, no minimums beyond a $5 top-up.

The tradeoff is NAT (no dedicated IPv4), but I've tried to make that less painful:

- Every account gets a /24 private subnet with full DHCP management. - Every server gets auto ssh port forwarding and a few TCP/UDP ports - Built-in HAProxy with Let's Encrypt SSL, load balancing, and auto-failover - WireGuard mesh between locations (Canada, Germany, UK currently) - PXE/iPXE boot support for custom installs - Email relay with DKIM/SPF - Recipe system for one-click deploys

Still in alpha. Small team, rough edges, but I've been running my own stuff on it for months. Would love feedback — especially on whether the NAT tradeoff kills it for your use cases, or what's missing. (IPv6 is coming) https://tierhive.com

I would like to share an open database focused on link-level metadata extraction and aggregation, which may be of interest to researchers.

The project maintains a structured dataset of links enriched with metadata such as:

- page title

- description / summary

- publication date (when available)

- thumbnail / preview image

- etc.

The goal is to provide a reusable, inspectable set of link metadata that can be used for experiments in areas such as:

- RSS and feed analysis

- news analysis

- link rot analysis?

The database is publicly available here:

https://github.com/rumca-js/RSS-Link-Database-2025

There are also databases for previous years

A fast SOCKS5 proxy that tunnels your traffic through what looks like normal SMTP email, bypassing Deep Packet Inspection firewalls.

How it works: - Client runs a local SOCKS5 proxy (127.0.0.1:1080) - Traffic is sent to server disguised as SMTP (EHLO, STARTTLS, AUTH) - DPI sees legitimate email session, not a VPN/proxy

Features: - One-liner install on any Linux VPS - Multi-user with per-user secrets and IP whitelists - Auto-generated client packages (just double-click to run) - Auto-reconnect on connection loss - Works with any app that supports SOCKS5

Tech: Python/asyncio, TLS 1.2+, HMAC-SHA256 auth

GitHub: https://github.com/x011/smtp-tunnel-proxy

The article discusses the development of the Isaac Robotics Simulation Engine, a high-fidelity simulation platform for robotic systems. It highlights the engine's capabilities, including support for complex robot models, realistic physical simulations, and diverse sensor representations.

The article discusses the process of creating an animated sprite hero using JavaScript and HTML5 canvas. It covers key steps such as loading sprite images, managing animation frames, and implementing user interactions to control the hero's movement and actions.

Just build a local tool for designing gears that kinda looks and works nice

Hey HN, We all know the pain: The code is clean, the product is solid, but the landing page isn't converting. I built Vect (vect.pro) to solve this. It’s an Autonomous Marketing OS, but the core feature is the Conversion Killer Detector. Instead of just "generating text", it acts as a hostile auditor. It simulates a skeptical buyer's inner monologue to flag exactly where your copy is vague, passive, or confusing. The Tech: Frontend: React + TypeScript (Command Center UI). Reasoning: Gemini 2.5 Flash for the audit logic. Simulation: It runs your copy through 10 distinct "Skeptic" personas to find friction points. It’s free to try the audit. I built this to help technical founders stop losing sales to bad copy. Link: https://vect.pro/

Author here! Some context: I published this 48 hours ago and it was auto-listed on MCPMarket (the MCP tools directory). Got 700+ organic downloads with zero marketing—developers were actively searching for exactly this solution.

The "Git Accelerator" optimization story:

Initially used a file walker that took 6.6s on Chromium. Profiling showed 90% was filesystem I/O. The fix: git ls-files returns 480k paths in ~200ms. Added smart heuristics for untracked files (only scan dirs <50k files), bringing total to 0.46s.

Why this matters: Agents can't wait 10 seconds for search. Sub-500ms makes it feel instant, changing how they explore codebases.

Installation:

  Cursor: npx mantic.sh@latest
  VS Code: npx mantic.sh@latest
  CLI: npm i -g mantic.sh

Happy to answer questions!

I've spent the last few months working on something I wish I'd had years ago. I kept running into the same issue: CI green, production mail broken. TLS handshake failures, DKIM alignment mismatches, SPF soft-fails ... the stuff that only surfaces when real mail servers are involved. Most test tools (Mailpit, MailHog) are catch-alls. They confirm "an email was sent" but don't validate the protocol. They also aren't designed for network-exposed environments: no auth, unprotected Web UI, easy to enumerate messages.

VaultSandbox is my attempt at fixing that. It's a self-hosted SMTP gateway (AGPLv3) that validates SPF, DKIM, DMARC, and rDNS on every incoming message. You keep your production email provider (Postmark, SendGrid, SES) in tests and you just change the recipient domain. No mocking, no config changes. There are client SDKs (Node, Python, Go, Java, .NET), plus a Web UI and a CLI for manual testing.

Some technical details:

Deterministic Tests Instead of polling or sleep loops, the SDKs use Server-Sent Events (SSE) so test assertions trigger the moment the mail hits the gateway.

Minimal infrastructure footprint Built with NestJS and Angular, with no external database dependency to keep the container footprint small and easier to reason about.

Post-Quantum Encryption I use ML-KEM-768 for the encryption layer. Incoming mail is encrypted immediately using a client-generated public key and the plaintext is discarded. The server only ever stores encrypted message data and cannot decrypt it. I chose PQ because I wanted to build something I wouldn't have to revisit in five years. If it handles large PQ keys reliably, everything else is easy.

Quick start: https://vaultsandbox.dev/getting-started/quickstart/

Site: https://vaultsandbox.com

I'd love feedback, especially on whether AGPLv3 would be a blocker for something you'd self-host in dev.

I built this because Cursor, Claude Code and other agentic AI tools kept giving me tests that looked fine but failed when I ran them. Or worse - I'd ask the agent to run them and it would start looping: fix tests, those fail, then it starts "fixing" my code so tests pass, or just deletes assertions so they "pass".

Out of that frustration I built KeelTest - a VS Code extension that generates pytest tests and executes them, got hooked and decided to push this project forward... When tests fail, it tries to figure out why:

- Generation error: Attemps to fix it automatically, then tries again

- Bug in your source code: flags it and explains what's wrong

How it works:

- Static analysis to map dependencies, patterns, services to mock.

- Generate a plan for each function and what edge cases to cover

- Generate those tests

- Execute in "sandbox"

- Self-heal failures or flag source bugs

Python + pytest only for now. Alpha stage - not all codebases work reliably. But testing on personal projects and a few production apps at work, it's been consistently decent. Works best on simpler applications, sometimes glitches on monorepos setups. Supports Poetry/UV/plain pip setups.

Install from VS Code marketplace: https://marketplace.visualstudio.com/items?itemName=KeelCode...

More detailed writeup how it works: https://keelcode.dev/blog/introducing-keeltest

Free tier is 7 tests files/month (current limit is <=300 source LOC). To make it easier to try without signing up, giving away a few API keys (they have shared ~30 test files generation quota):

KEY-1: tgai_jHOEgOfpMJ_mrtNgSQ6iKKKXFm1RQ7FJOkI0a7LJiWg

KEY-2: tgai_NlSZN-4yRYZ15g5SAbDb0V0DRMfVw-bcEIOuzbycip0

KEY-3: tgai_kiiSIikrBZothZYqQ76V6zNbb2Qv-o6qiZjYZjeaczc

KEY-4: tgai_JBfSV_4w-87bZHpJYX0zLQ8kJfFrzas4dzj0vu31K5E

Would love your honest feedback where this could go next, and on which setups it failed, how it failed, it has quite verbose debug output at this stage!

Two years ago, someone on HN shared an interesting ADHD hack: a tiny LED that blinks at 120 bpm and gradually slows to 60 bpm, supposedly helping your brain sync and calm down into focus mode.

I found Qiaogun's implementation (ADHD_Blink) for M5StickC Plus, and adapted it for the newer M5StickC Plus2 with some tweaks - simpler 50% duty cycle flash, configurable ramp-down, auto sleep, etc.

Honestly, I'm not sure if it actually works. I'll be trying it out myself to see. But the building process itself was quite fascinating.

I used Claude Code for the entire implementation - from reading the original codebase, to modifying the firmware, to flashing the device. There's something surreal about an AI having full control over a physical piece of hardware.

It made me wonder: in the future, could AI-connected devices dynamically rewrite their own firmware based on user needs? Imagine telling your device "make this button do X instead" and it just... does.

Original HN comment: https://news.ycombinator.com/item?id=38274782 Based on: https://github.com/Qiaogun/ADHD_Blink Hardware: M5StickC Plus2 (~$20)

Happy to hear thoughts, or if anyone has actually tried this LED trick.

Why - I got sick of apps abusing notifications on my Android phone. While the OS does give you the ability to switch off notifications based on channels, most apps either don't use it or abuse it intentionally. In my case, I live in a gated society that uses an app called MyGate to allow visitors, and the app intentionally pushes ads through the same channels since you cannot block them.

What - DoNotNotify is an app that logs all incoming notifications, and displays them grouped by app. It also captures the action behind the notification, which can be triggered from the app itself. From this log, you can create rules to whitelist/blacklist notifications from apps depending on their notification content. These filters can even be regex expressions, which allows for more complicated use-cases. The app ships with some pre-defined rules for popular apps like Facebook, Amazon, Instagram, Netflix, TikTok, Reddit etc.

Where - The website is at https://donotnotify.com/.

Would also like to call out that the app runs purely on your device, never communicates with anything on the Internet, and only requires notifications access to work. It is completely free, and there is no advertising or hidden gotchas.

The article discusses Git Prime, a web-based tool that helps developers manage their Git repositories more effectively. It provides features like project monitoring, code review, and team collaboration to improve the software development workflow.

Hey HN,

Claude Code is pretty agentic now. It writes scripts, calls APIs, uses CLIs. But when something requires actually clicking through a website, it stops and asks me to do it.

Problem is, I'm often unfamiliar with these platforms myself. "Go to App Store Connect and generate a P8 key" okay but where? I end up spending 10 minutes navigating menus I've never seen before.

I started delegating these tasks to Perplexity's Comet browser. It handles the clicking, returns what I need. But copy-pasting between Claude and Comet got old fast.

So I built this MCP server to connect them directly. Now when Claude needs to interact with a website that has no API, it can just ask Comet to handle it.

  Examples:
  - Grab my app ID from RevenueCat dashboard
  - Generate a P8 key in App Store Connect
  - Navigate admin panels behind login walls

Comet doesn't have an API, so this uses CDP to communicate with it directly.

Hi HN, I'm Barry and I've built Prism.Tools (https://blgardner.github.io/prism.tools/) – a collection of client-side developer utilities that respect your privacy.

Many of these tools were used way back in the days when I ran a BBS and started my communities first ISP, serving three local communities with Dial-Up Internet, Web Hosting etc. The tools have been refined to reflect the changes in tech since then and designed for the Novice and Pro alike. As I locate more tools others may find useful I will refine and add them to the collection. Use them, Share them, or not. They will be here if you need them...

40+ dev tools (JSON formatters, regex tester, base64 encoder, Git command helper, etc.) that run entirely in your browser. Zero tracking, zero analytics, zero data collection – everything processes locally. Self-contained HTML files with no build process or frameworks.

I realized I had a lot of tools/utilities I've built over the years for my own use. I lothe having to 'sign-up' just to access/use simple utilities that I can create myself. I've refined them and put them in one safe place so I could easily access them if/when needed. I decided to make them available via Github Pages for anyone that may find them useful. Prism.Tools is the result.

Each tool is a standalone HTML file with embedded CSS and JavaScript. No frameworks, no npm packages, no build steps – just open the file and it works.

The entire toolset:

- 100% client-side processing – your data never leaves your browser.

- No external dependencies except for specific libraries from cdnjs.cloudflare.com (marked.js for markdown, exifr for image metadata, etc.)

- Consistent dark UI – every tool follows the same design language for familiarity.

- Vanilla JS where possible – only reaching for Public CDN Resources when necessary.

The constraint of "single HTML file" was intentional. It forces simplicity and ensures tools remain maintainable. It also means users can inspect, modify, or self-host any tool trivially.

These tools have helped me with debugging production issues, Quick formatting tasks, learning Git commands (the Git command helper has been particularly helpful)

Just visit https://blgardner.github.io/prism.tools/ and try any tool. No signup, no install.

What tools are missing that you find yourself needing? Any performance issues with specific tools? UI/UX friction points?

All tools follow the same privacy-first philosophy... Your data stays in your browser. No accounts, no tracking, no servers processing your information. The project is also a demonstration that you don't always need React, Vue, or complex build pipelines – sometimes vanilla JavaScript in a single HTML file is exactly the right tool for the job.

Vanilla JavaScript (ES6+) CSS3 with CSS Grid Minimal external libraries: marked.js, exifr, highlight.js, sql-formatter (all from CDN) No frameworks, no bundlers, no npm Hosted on Github Pages

Happy to answer questions about the technical implementation, design decisions, or specific tools!

All tools are inspectable – just view source on any page to see exactly how they work!

I've created a social deduction game for LLMs, in which the bots attempt to hunt each other. It's a Mafia group turing test: the models are told to find who the bot is - where, in fact and unbeknown to them, they are all bots. I did this a while back so models aren't the newest, and they are all non-thinking (for speed and token costs). Et voilà.

Raymond here from Butter.dev, an LLM response cache built as a chat-completions proxy. Today we're launching a key feature for the platform: the ability to generalize on dynamic, templated inputs.

Caching at the HTTP request level has the obvious problem of generalizability. Nearly no request is identical, due to templated variables (like names) and metadata (like timestamps), so exact-match cache lookups rarely hit. We solve this at Butter by using LLMs to detect dynamic content in requests and derive their inter-relationships, allowing the cache entry to be stored as a template + variables + deterministic code. This allows future requests to contain different variable data, yet still serve from cache.

We've found this approach greatly improves cache hit rate, and believe it could be useful for agents performing repetitive back-office tasks, computer use, or data transformations where input data is frequently of the same shape.

- You can see a demo of learning patterns here: https://www.youtube.com/watch?v=ORDfPnk9rCA

- We wrote more about the technical approach here: https://blog.butter.dev/on-automatic-template-induction-for-...

- It's free to try out here: https://butter.dev/auth