2026年4月5日 の Show HN
37 件OsintRadar – Curated directory for osint tools #
Enter an Instagram/TikTok handle, get a data-backed price for collab #
mailtrim – find what's actually filling your Gmail inbox #
I built mailtrim to surface this pattern:
- ranks senders by actual storage impact (not just count)
- confidence scoring on what's safe to bulk-delete
- 30-day undo on everything — nothing is permanent by default
- runs entirely locally, no email data leaves your machine
Free, open source (MIT). No subscription, no backend.
One friction point upfront: Gmail API setup is one-time, ~15 min.
After that it's just `mailtrim stats` and `mailtrim purge`.
Keen to hear feedback on the confidence/safety model especially —
that's the part I'm least sure I've got right.
https://github.com/sadhgurutech/mailtrimCabinet – Kb+LLM (Like Paperclip+Obsidian) #
for quite some time I've been thinking how LLMs are missing the knowledge base, where I can dump CSVs, PDFs, and most important, inline web app. running on Claude Code (bring your own agent) with agents with heartbeats and jobs
It runs locally and is installable via npm. GitHub (open source): https://github.com/hilash/cabinet
This is still very early. I put the first version together quickly after seeing a post by Andrej Karpathy about LLM knowledge bases, which matched closely with what I’d been building. Some people have already started trying it and opening PRs, which has been encouraging (got 374 stars in 2 days :] )
If useful: Waitlist for a hosted version: https://runcabinet.com/waitlist Discord (small, but growing): https://discord.gg/rxd8BYnN
Would really appreciate feedback: does this “KB + agents” model make sense? what would you expect from a system like this? where does this fall apart? Happy to answer anything.
Hila
ACE – A dynamic benchmark measuring the cost to break AI agents #
We tested six budget-tier models (Gemini Flash-Lite, DeepSeek v3.2, Mistral Small 4, Grok 4.1 Fast, GPT-5.4 Nano, Claude Haiku 4.5) with identical agent configs and an autonomous red-teaming attacker.
Haiku 4.5 was an order of magnitude harder to break than every other model; $10.21 mean adversarial cost versus $1.15 for the next most resistant (GPT-5.4 Nano). The remaining four all fell below $1.
This is early work and we know the methodology is still going to evolve. We would love nothing more than feedback from the community as we iterate on this.
Where Is Artemis? #
The domain (whereisartemis.com) was available and I thought "someone should use that", bought the domain and got started. Hopefully, this is something that can be extended for future Artemis missions and help build engagement for the Artemis program and space travel in general :)
The tracker includes: - Real-time 3D scene with toggleable camera views (top-down or free orbit), - Live telemetry: Distance from Earth/Moon, current speed etc. - Live video from NASA - Mission schedule with countdowns to upcoming events (lunar flyby, splashdown, etc.) - Mission coverage with links to NASA articles - Mobile and desktop support
How it works under the hood:
- Live position and trajectory data is pulled directly from the NASA/JPL Horizons API. - Built with Next.js, React Three Fiber/ThreeJS, and Tailwind CSS.
Github: https://github.com/larsmoa/whereisartemis2 (feel free to add issues with suggestions :) )
A Dad Joke Website #
Help me create the worlds best dadabase!
Arbory – Native iOS dashboard and widgets for Plausible Analytics #
Long-time lurker (2017) here, but finally something to post about.
I've been building an iOS companion app for Plausible over the past few months. There are some great ones out there already, but I have always wanted to try building an app first-hand. I'm quite proud of the end result, so I wanted to share it online to see if people would be interested in using it.
In case you don't know: Plausible Analytics (https://plausible.io/) is a privacy-friendly alternative to Google Analytics. You can self-host it or choose to use their SaaS platform.
I chose Plausible Analytics because of their business philosophy: Privacy should come first. Arbory is built to connect directly to Plausible (either SaaS or self-hosted).
Features include:
- iOS Liquid Glass-native dashboard displaying most of your website analytics.
- Tap to filter data, just like Plausible itself.
- Notifications for traffic spikes and drops, the algorithm lives fully on your phone. (I'm quite proud of this one in particular)
- Full suite of widgets for your lock & home screen.
There are no subscriptions involved. You'll get the full dashboard and filtering for one site for free. There's a one-time unlock for $14.99 for the rest, if desired.
I'll lurk around here to answer any questions you might have. Any feedback is appreciated.
More information:
- Website: https://arbory.io
- Privacy Policy: https://arbory.io/privacy
- App Store Link: https://apps.apple.com/app/id6760103214
Full disclosure (some people find this important): AI helped me build parts of this, but I've been a software engineer for 15+ years. Happy to answer any technical questions.
Crabby – Claude Code skill that reviews code like the Rust compiler #
The format works for code review, writing review, architecture, strategy - anything you submit. The "writing review" example tends to surprise people: it flags passive voice in a postmortem with the exact same error[W002] format as a SQL injection.
Fabro – open-source dark software factory #
Fabro helps experienced engineers evolve towards a “dark” software factory where average time between disengagements increases. It’s easy to throw a Ralph shell script around Claude, but as runtime increases the chance of high quality output declines.
Fabro adds the last mile of guardrails to make it actually work: combining deterministic workflows of agents, commands like linters and test suites, with strategically applied human steering. (Similar to the Stripe's Minions.)
Fabro is multi-model and makes it easy to combine Claude, Gemini, and GPT in ensemble reviews — or delegate coding to faster and cheaper models like Kimi.
Software factories work best when combined with cloud VMs (like Daytona) so you get infinitely scalable, secure sandboxes that can run 24/7 and accessible via SSH, VS Code, and preview links as needed. This can be a bit of a pain to set up today and Fabro tries to make it as easy as Docker.
The closest analog to Fabro today would be something like Factory.ai Droids. However, I think it’s critical for engineers to own their own toolchain and so Fabro is open source (MIT) so you can fork it and customize it anytime.
The project is highly active and I’d love any feedback or feature requests. I’ll be on here answering questions today.
(Had posted this a week or so, hoping to engage in some conversation.)
-Bryan
I built a tool to show how much ARR you lose to FX fees #
I started my career as a finance manager, transitioned into product management, and now I’m building my own products.
Back in my finance days, while managing a £6M budget, I uncovered a £15k leak hiding in plain sight: FX fees.
Today, I see solo founders making the exact same mistake. I realised most founders are quietly losing 2-5% of their revenue to what I call the Lazy Tax: - Stripe's ~2% auto-conversion fee on inbound revenue, - plus their local bank's ~3% spread when paying for global SaaS tools (AWS, Claude, Ads).
So I built FixMyFX to show founders their exact leak and how to fix it (using multi-currency accounts to achieve a zero FX leak setup).
Initially, I had Claude build this in React. Realised a simple calculator shouldn't need a 150kb payload and a complex build process. Threw the React code away and rebuilt it as a single lightweight HTML file using Alpine.js and Tailwind.
It's completely free and ungated. I hope it helps you keep a bit more of your hard-earned revenue. Would love your feedback.
Tania
Sigil – A new programming language for AI agents #
What makes Sigil good for coding agents?
I've turned conventions into compiler rules whenever possible. The compiler owns the canonical printer and every AST has one accepted textual representation. For almost every syntax feature I tried to save tokens.
Order and naming conventions are enforced. No more "I think this argument is important so it should come first." Most things are alphabetical. Declarations are categorized and ordered alphabetically; parameters, effects, and record fields are alphabetical too. Types are UpperCamelCase. Everything else is lowerCamelCase, including file names.
No nulls. No undefined. Bidirectional type checking. No shadowing. Fat stdlib (still in progress). `sigil debug` supports replay, stepping, watches, and breakpoints. `sigil inspect` lets coding agents query the compiler directly, including proof surfaces.
Solver-backed refinements and contracts. Different languages already choose different numeric surfaces: byte, short, smallint, unsigned integers, etc. Sigil pushes that one step further: domain constraints can also define types. `where` lets a named type carry a predicate, and `requires` / `ensures` let functions carry proof obligations across call boundaries.
Here is a contrived example from the roguelite:
t InventoryCount=Int where value≥0
λspendArrow(arrows:InventoryCount)=>InventoryCount
requires arrows>0
ensures result≥0
=arrows-1
No imports, rooted references only. In some languages you can import code and have name clashes, so there are many ways to specify imports. Sigil eliminates all of that by only using rooted references. I think this reduces agent churn because when the model sees a line, it does not have to go hunt for an import statement.
Service dependencies are declared in `src/topology.lib.sigil`, and environment bindings live in `config/<env>.lib.sigil`.
The language has special syntax for tests and they are run in parallel. Every project `src/*.lib.sigil` function must be tested, and if a function can return multiple cases, tests should exercise all of them. "World" is Sigil's model for effects. That is how mocks work: swap one effect for another and make assertions without exercising real external systems.
The compiler toolchain is written in Rust, and Sigil outputs to TypeScript, with a Foreign Function Interface to Node.js. See some small projects here https://inerte.github.io/sigil/projects/ - the Flashcards is useful to learn about Sigil features https://inerte.github.io/sigil/projects/sigil-flashcards/dem...
Caveat: I did NOT type a single line of code for the compiler toolchain. It was all generated with Claude Code and Codex. I run both with permissions dangerously skipped. This actual post I hand crafted every word.
There is also a toy roguelite written in Sigil. It is a work in progress, but it is proof that Sigil can support nontrivial project code. You can play with `pnpm sigil:run:roguelike`.
Repository: https://github.com/inerte/sigil
Website: https://inerte.github.io/sigil/
And I would love if you can find ways to lock down LLM / user programs even more. In Sigil, there should be only one way to do anything.
Sshifu – Give SSH access in 1 command. Teleport/Smallstep alternative #
I looked into solutions like Teleport and Smallstep, but they felt a bit too heavy and complex for what I needed.
So over the past few weeks I vibe-coded a small solution to scratch my own itch: sshifu.
The idea is simple — you set up a “sshifu server” as an auth server, configure your SSH servers to trust it, and then giving access is just telling someone to run:
"npx sshifu sshifu-server.com ssh-server.com"
That’s it. No more copying keys or touching "authorized_keys".
It’s still early and a bit rough around the edges, but it’s been working well for me so far.
Would love feedback — what’s missing for real-world usage, and what would stop you from using this?
Beautiful intuitive weather forecasts that don't rely on numbers/units #
- Compare current/future conditions with weather you experienced the day before
- Understand/compare how conditions change through out the day
---
WeatherSense started out as a hand-coded project: https://github.com/Leftium/weather-sense
- Would you consider this project a good example of how AI can be used to enhance coding?
- Claude helped implement many new features from the backlog, like 60-min precipitation forecasts
- Claude helped add some whimsical features: I only considered adding because AI made it cheap to experiment:
* "Calm mode:" truly emphasizes how WeatherSense doesn't need numbers by removing/replacing all numbers from UI
* Dynamic background color based on sun angle
---
Major inspirations:
- DarkSky
- MerrySky (https://merrysky.net)
Signals – finding the most informative agent traces without LLM judges #
Salman, Shuguang and Adil here from Katanemo Labs (a DigitalOcean company).
Wanted to introduce our latest research on agentic systems called Signals. If you've been building agents, you've probably noticed that there are far too many agent traces/trajectories to review one by one, and using humans or extra LLM calls to inspect all of them gets expensive really fast. The paper proposes a lightweight way to compute structured “signals” from live agent interactions so you can surface the trajectories most worth looking at, without changing the agent’s online behavior. Computing Signals doesn't require a GPU.
Signals are grouped into a simple taxonomy across interaction, execution, and environment patterns, including things like misalignment, stagnation, disengagement, failure, looping, and exhaustion. In an annotation study on τ-bench, signal-based sampling reached an 82% informativeness rate versus 54% for random sampling, which translated to a 1.52x efficiency gain per informative trajectory.
Paper: arXiv 2604.00356. Project where Signals are already implemented: https://github.com/katanemo/plano
Happy to answer questions on the taxonomy, implementation details, or where this breaks down.
Yoink functionality from dependencies and avoid supply chain attacks #
yoink runs as a three-step, agent skills-based workflow:
1. /setup clones the target repo and scaffolds a replacement package.
2. /curate-tests generates tests verified against the original's expectations.
3. /decompose determines dependencies to keep or decompose based on principles such as "keeping foundational primitives regardless of how narrow they are used".
We built yoink in response to the five major supply chain attacks that happened in two weeks, including LiteLLM and axios. We install most of these packages without thinking twice.
Andrej Karpathy recently called for re-evaluating the belief that "dependencies are good". OpenAI echoed this in their harness engineering article: agents reason better from reimplemented functionality they have full visibility into, over opaque third-party libraries.
yoink makes this capability accessible to anyone.
Refer to the GitHub repo to install the plugin to Claude Code: https://github.com/theogbrand/yoink
Love to hear what you think!
macOS PDF Organizer Using Apple Intelligence #
Elephant Folio will organize your PDFs, suggest better filenames, index them and tag them; all on-device. Additionally, it features a Safari extension, so you can import PDFs you find from HN straight into Elephant Folio's library, or anywhere else you get your PDFs.
Let me know what you think!
Ragot – a front end runtime built around lifecycle and ownership #
I ended up writing my own runtime because existing frameworks didn’t handle lifecycle, state ownership, and long running UI cleanly enough for that use case.
It focuses on direct DOM ownership, explicit lifecycle control, and predictable cleanup instead of a virtual DOM.
Open sourcing it to see if this approach resonates with others building similar systems.
There’s an interactive lab in the repo, but here’s a direct link: https://bleedingxiko.github.io/RAGOT/lab/
Vim Navigator – MCP server that lets AI agents drive your Neovim #
The tool I actually wanted was "walkthrough mode": I ask the agent to walk me through a PR, it opens each file, highlights what matters, explains briefly, and waits for my questions. Turns code review into pair programming where the agent points at the screen.
It also works passively — while the agent investigates a bug or reads code, my Neovim follows along so I can see what it's looking at.
Built with pynvim, talks to Neovim via --listen socket. Works with any MCP client.