value: tombh

value:
We're Tom and Ryan and we teamed up to build an algorithm with Rust and SIMD to exhaustively search for the longest line of sight on the planet. We can confirm that a previously speculated view between Pik Dankova in Kyrgyzstan and the Hindu Kush in China is indeed the longest, at 530km.
We go into all the details at https://alltheviews.world
And there's an interactive map with over 1 billion longest lines, covering the whole world at https://map.alltheviews.world Just click on any point and it'll load its longest line of sight.
Some of you may remember Tom's post[1] from a few months ago about how to efficiently pack visibility tiles for computing the entire planet. Well now it's done. The compute run itself took 100s of AMD Turin cores, 100s of GBs of RAM, a few TBs of disk and 2 days of constant runtime on multiple machines.
If you are interested in the technical details, Ryan and I have written extensively about the algorithm and pipeline that got us here:
* Tom's blog post: https://tombh.co.uk/longest-line-of-sight
* Ryan's technical breakdown: https://ryan.berge.rs/posts/total-viewshed-algorithm
This was a labor of love and we hope it inspires you both technically and naturally, to get you out seeing some of these vast views for yourselves!
1. https://news.ycombinator.com/item?id=45485227

value: Show HN: Algorithmically finding the longest line of sight on Earth

author: tombh


value: Show HN: GW – manage Git worktrees when you're babysitting multiple AI agents


value: kamban

value: Show HN: Voice-to-voice translation for meetings (macOS, alpha)

author: kamban


value:
Single-agent setups hit a scaling limit.
Agents that are overloaded with skills and integrations, get slower and less reliable, just when coding agent hit their context window limits.
That's why we built Operator (https://operator.io): a hosted way to spin up/down small, specialized OpenClaw instances so each one stays focused.
Happy to set you up with an early access / founder discount at david [at] operator.io.

value: Show HN: OpenClaw Swarm as a Service (YC W20)


value: bogozi

value:
Since the last Show HN 7 months ago, I've shipped some major updates:
• Operators Directory – browse 160+ crawlers by company (Google, OpenAI, Anthropic, etc.). See all their bots, safety stats, and official docs in one place.
• Enhanced crawler profiles with "Blocking Impact" analysis and common use cases
• Added 25+ new AI crawlers including latest models and scrapers
• Bulk robots.txt generator – generate allow/block rules for all filtered bots in one click
• RFC 9309 strict compliance – mimics Googlebot's exact "Longest Match" logic
The tool now helps answer "who owns CCBot?" or "show me all OpenAI crawlers" which came up a lot in the original thread.
Still built with Go + Svelte, still free, no signup required.
Feedback welcome!

value: Show HN: CrawlerCheck v1.5 – Operators Directory and 25 new AI crawlers

author: bogozi


value: dmehers

value:
I know there are many TV tracking apps out there, many that people love, but none worked for me. Too cluttered, trying to tell me what I should watch next, share, rate, etc. Probably AI recommendations too.
I don't want any of that. I just want to know what episodes I've watched, and what is next.
So I've made that app, called TV Next, currently in TestFlight and I'd love feedback: https://testflight.apple.com/join/CVHfUaD2
If I release it, it will be free, with a tip jar.

value: Show HN: I created a de-ensh*tified TV tracking app

author: dmehers


value: geniusyan

value: I built NanoSLG as a minimal, educational inference server for LLMs like Llama-3.1-8B. It supports Pipeline Parallelism (split layers across GPUs), Tensor Parallelism (shard weights), and Hybrid modes for scaling.

value: Show HN: NanoSLG – Hack Your Own Multi-GPU LLM Server (5x Faster, Educational)

author: geniusyan


value: vinzdg

value:
Hello HN, I'm Vinz.
Based on my experience running a small design agency based on recurring monthly, i found a little issues with invoicing and subscription tracking for my clients, i was counting and create booklog manually on my notes and started to get a little headache with those repetitive works.
So i made Sundaysub, a little platform for me to create my invoice and save it easily. I don't have to create the product or write what product to deliver for several times, i can save it there. Also, i tried to improve the UI inn a POS-style format. On the left you can get lists of your products services, and you can record it in the order summary and complete the transactions.
I thought this is a helpful app that i've used personally for my agency, now i tried to open this app for free on public. Hope this would be helpful.

value: Show HN: I made Sundaysub to help small startup create invoice for free

author: vinzdg


value: mathysth

value:
Hey HN,
I'm a solo dev and I built Invocrea because I was tired of spending hours every month on invoicing. Most tools out there are bloated, expensive, or just ugly.

  Invocrea lets you create and send professional invoices in under 30 seconds. The stack is Next.js + NestJS + MongoDB.

  The feature I'm most excited about: AI-generated invoice templates. You describe the style you want, and it generates a custom template for you. No more generic-looking invoices.

  What it does:
  - Create invoices/quotes with smart auto-completion
  - Track payments (paid, pending, overdue) in real-time
  - Automatic reminders for unpaid invoices
  - Professional PDF export with your branding
  - AI-powered template generation
  - Client management with full billing history

  It's free to start. If you want to try a paid plan, use code AVSE78 for 30% off.

  Would love your feedback on the product and the AI template generation. What would you improve?

value: Show HN: I built an invoicing SaaS with AI-generated invoice templates

author: mathysth


value: hashmakjsn

value:
I’ve been experimenting with using SQLite as a key–value store without going through the SQL layer.
SQLite’s B-Tree implementation is extremely mature and well-tested, but most access goes through the SQL compiler, VDBE, and query planner. I wanted to see what happens if you bypass all of that and interact directly with the B-Tree APIs.
The result is a small prototype KV store that:
Uses SQLite’s internal B-Tree interfaces directly
Avoids parsing, planning, and VDBE execution
Keeps SQLite’s ACID guarantees intact
In local benchmarks with mixed read/write workloads, this approach showed noticeably lower overhead compared to equivalent SQL-based access patterns.
please let me know if you face any bug, let me know area of improvements that i can add in it.

value: Show HN: Developed key value storage using SQLite's b-tree APIs directly

author: hashmakjsn


value: oftentom

value:
I often use GPT by asking it to challenge my thinking with questions, and that worked surprisingly well for clarifying my own ideas. I recently had an interview coming up, so I built this small web app (using Codex) that acts as an interviewer and drills follow-up questions—so I can practice the “go deeper / explain why” pressure.
When I realize I don’t actually know something, I use that gap to study right away. After the session, I can download the transcript and paste it into Notion/Obsidian for review.
It’s currently running on my own API credits, so I’m not sure how long it will stay up. If you try it, I’d really appreciate blunt feedback:
Do the follow-up questions feel realistic?
What part felt awkward or unhelpful?
What’s the one feature you’d expect next?

value: Show HN: An AI mock interviewer that keeps asking follow-ups (export transcript)

author: oftentom


value: appecta

value:
I've always found the raw CIA World Factbook data to be one of the most incredible open-source collection human made. The official website was shut down on February 4, 2026, without any apparent reason.
I found out that a project named factbook.json fetches and stores the data weekly. The idea of making a clean ui popped into my head that moment. After struggling a couple of hours and with the help of agentic ai tools, I finalized it. The project is open source as the factbook, it is open to all your PR's, updates to UI or updates to the information in it (with source ofc).
GitHub: https://github.com/appecta/cia-worldfactbook/
Live Demo: https://appecta.github.io/cia-worldfactbook/
Hope the community finds this useful!

value: Show HN: CIA World Factbook with Most Current Data and Modern UI

author: appecta


value: vhsdev

value:
This is an educational reference implementation showing how to build reasonably secure, standards-compliant authentication from first principles on Cloudflare Workers.
Stack: Hono, Turso (libSQL), PBKDF2-SHA384 + normalization + common-password checks, JWT access + refresh tokens with revocation support, HTTP-only SameSite cookies, device tracking.
It's deliberately minimal — no OAuth, no passkeys, no magic links, no rate limiting — because the goal is clarity and auditability.
I wrote it mainly to deeply understand edge-runtime auth constraints and to have a clean Apache-2.0 example that follows NIST SP 800-63B / SP 800-132 and OWASP guidance.
For production I'd almost always reach for Better Auth instead (https://www.better-auth.com) — this repo is not trying to compete with it.
Live demo: https://private-landing.vhsdev.workers.dev/
Repo: https://github.com/vhscom/private-landing
Happy to answer questions about the crypto choices, the refresh token revocation pattern, Turso schema, constant-time comparison, unicode pitfalls, etc.

value: Show HN: Minimal NIST/OWASP-compliant auth implementation for Cloudflare Workers

author: vhsdev


value: alexjreid

value: Show HN: xllify: Turn formulas, VBA, or plain English into Excel add-ins

author: alexjreid


value: barakber

value:
I built an eBPF tool that hooks into the kernel to monitor and enforce policies on LLM/AI traffic in real time — no application changes needed.
It attaches uprobes to OpenSSL's SSL_write/SSL_read to capture decrypted payloads, classifies traffic to 12+ LLM providers (OpenAI, Anthropic, Google, etc.), detects MCP JSON-RPC calls, and can block connections in-kernel via LSM
hooks.
You can write inline Rego policies for enforcement. For example, deny any request to Anthropic containing a specific keyword:
sudo busted monitor --enforce --rule 'package busted
  default decision = "allow"
  decision = "deny" {
    input.llm_provider == "Anthropic"
    contains(input.tls_payload, "secret_project")
  }'
Everything is Rust — eBPF programs, userspace agent, classifier, policy engine, and native egui dashboard. Built with Aya.
https://github.com/barakber/busted

value: Show HN: Busted – eBPF tool that monitors what your AI agents send

author: barakber


value: eddelgado

value: Show HN: Kodus – Open-Source Alternative to CodeRabbit

author: eddelgado


value: hjotha

value:
Hi HN,
I built a small experiment called iamthericher.com
There is always only one “Richer”.
To take the title, you pay $1 more than the previous person.
If no one takes it for 14 days, it resets.
There’s no utility, no product, no link placement, no ads.
Just status, ego, and curiosity.
I wanted to see if people would pay for something that openly does nothing.
Feedback welcome.

value: Show HN: A website that proves you are richer than everyone else

author: hjotha


value:
I’ve spent the last few months working on MadLab. I wanted something that felt as polished as LM Studio but focused entirely on the training side of the house.
It’s a standalone desktop app (Windows/Linux/macOS) that automates the entire environment setup—GPU detection, PyTorch wheel selection, and venv creation—so you can go from zero to training in a few minutes. Under the hood, it’s managing the trainer logic for LoRA, QLoRA, and DoRA. One thing I’m experimenting with is a built-in Chat Assistant that acts as a fine-tuning coach. It doesn't just run commands; it helps recommend hyperparameters based on your model size and hardware limits. It's 100% open-source. I’d love to get some feedback from this community on the environment automation and the training UI. I'll be around to answer any technical questions!

value: Show HN: MadLab – A standalone desktop app for local LLM fine-tuning


value: ramsbaby

value: Show HN: OpenClaw Self-Healing v2.0 – AI that diagnoses and repairs itself

author: ramsbaby


value: memy is intended as a remixing of the concepts of zoxide and fasd, a tool to track files and directories you use frequently. Written in Rust and using SQLite, it's modern, fast, and flexible, intended primarily as a backend for you to built meaningful ways to use the output.

value: Show HN: Memy – track and find directories and files you use frequently [video]


value: schwad

value:
Every year, foreign governments give gifts to US government officials — everything from jeweled swords to luxury watches to ornate rugs. Federal law requires these to be disclosed (and most go to the National Archives, since officials can't keep gifts worth over ~$480).
I built FederalGifts to make this data browsable and searchable. You can explore by:
-  Individual gifts (with descriptions and estimated values)
-  Recipients (which officials received the most?)
-  Donor countries (which nations give the most lavishly?)
-  Agencies
Some interesting finds: Saudi Arabia and UAE consistently give the most expensive gifts. The most common gifts are jewelry, decorative items, and books. The State Department receives the lion's share.
The data comes from the Federal Register and State Department disclosures — public information that's technically available but practically impossible
to browse.
Built with Rails and open data. No login required, no tracking.

value: Show HN: FederalGifts – What foreign governments give American officials

author: schwad


value: yamigopal

value:
Author here. We've been building agent trust infrastructure for ~1 year (12 microservices for identity, behavior monitoring, data governance, etc).
When the CSA published their Agentic Trust Framework spec, we realized our stack maps to all 5 elements — but the spec has no reference implementation. So we built one.
What we added that the spec leaves open:
- Maturity model runtime (agents earn autonomy through 5 promotion gates)
- Policy-as-code segmentation engine (real-time access decisions)
- Circuit breaker for incident response (auto-containment)
Everything is MIT. You can clone the repo and run `npm test` — 25 contract validation tests.
Repo: https://github.com/yogami/atf-reference-implementation
Interactive demo: https://berlinailabs.de/atf-demo.html
Happy to answer architecture questions.

value: Show HN: Open-source zero-trust framework for AI agents- 12 services, all tested

author: yamigopal


value: rebelchrisycom

value:
Hey HN! I built susscore because I got tired of hovering over links wondering "is this a phish?"
It's fully open source and runs 11 checks in real-time:
• Domain age & reputation
• SSL certificate validation
• Known phishing database lookup
• Brand impersonation detection (40+ brands)
• URL pattern analysis (typosquatting, suspicious paths)
• Redirect chain inspection
• And more...
No signup, no tracking, just paste and go.
GitHub: https://github.com/rebelchris/susscore
Built with Next.js. PRs welcome, especially for adding more brand patterns or regional phishing detection.
What checks would you want to see added?

value: Show HN: Susscore – Open-source link scanner to check if a URL is sketchy

author: rebelchrisycom


value:
I created a site (https://printableclassics.com) that allows you to download classic books and customize things like the font size, page size, and the cover.
As part of this, I wrote a software pipeline that takes epubs, html files, or pdfs and converts them into formatted books with custom covers, page numbers, chapter formatting, etc.
I used an LLM for categorizing the books. There's a nice way to filter such that you could easily find "Young Adult, Ancient, Fantasy" for example.
When downloading from the site, the PDFS are rendered in a work queue. Hopefully the server I'm using won't get overwhelmed. It takes around 10-15 seconds to generate for most books.
Most of the books currently on the site are from Standard Ebooks. I plan to add more books from Archive.org and Project Gutenberg over time.
I also created a little guide on how you can print and bind books at home with around $200 in equipment. (https://printableclassics.com/print-guide)
Printable versions of the Harvard Classics are available here: https://printableclassics.com/harvard_classics This is an example of direct PDF conversion.
Hopefully this is useful to some people. I plan to use the books here for home education myself so it will at least be useful to me. I'd like to add a guide with top suggestions by age level and some educational theory on how I made the selections. I'm happy to take any feedback on the site or answer any questions.
There is also the option to have the books professionally printed through a print on demand provider. I'm hoping that could be a way to pay for the site hosting.
Thanks for checking it out!

value: Show HN: Printable Classics – Free printable classic books for hobby bookbinders


value: seyz

value: Show HN: ClawBands – Mitigating OpenClaw prompt injection via tool hooks

author: seyz


value: royatthreesigma

value:
I was being asked to fix a lot of Lovable projects for prod and it was painful because it was a messy codebase. So I built shippable where people can vibe code in an opinionated stack with live dev environment so the result is more predictable.
Current setup is not elegant (stringed along on django + drf + nextjs + shadcn + digital ocean droplets + docker compose). But I found it was much easier for the llm (Claude) to do a cleaner job when it had the dev environment available and has real runtime feedback.
Took me a while to build it over January, but I want to know what you think.
Link:  https://app.shippable.build/
There’s a signup + free credit limit to prevent abuse. If you want more credits lmk here and I can add them manually.

value: Show HN: Shippable – Lovable but with live dev environment (Django+Next)

author: royatthreesigma


value: andrewspode

value:
A friend and I made this project (with a little help from Claude, naturally).
We wanted to create a wordle-esque shared experience, so everyone gets the same quests and those quests should have some meaningful impact on your day.
The approach we took was to create around 100 sentence structure templates that used a selection of verb and noun arrays. These were nested so depending on the sentence you might want all "things" (a very large list) or perhaps more granular like "things.furniture".
We had multiple categories/sub-categories and put around 100 words in each, giving us millions of possibilities - more than enough for selecting 9 each day for a while.
The outcome is some really quite surreal quests - hence the tagline, 'daily mindful side quests that'll make you say "what?"'
I have personally found them to be quite useful. They stop and make you think, doing quite mundane things with a mindful lens (like "appreciate a pot you might usually ignore"), or stretching yourself to do something new.
When I sent it to a friend, one of the quests was to "make a pizza from scratch". Several hours later, he messaged me saying that he had caved as it was the last quest on his list, so he did it and felt better for it.
So nothing crazy from a technical perspective going on here (except perhaps denying the thought of simply having AI create the quests for us) but definitely something worth sharing IMO!

value: Show HN: Questle – Daily Mindful Side Quests That'll Make You Say What?

author: andrewspode


value: prplfsh

value:
It uses your local Claude and GitHub CLI and git worktrees, so there's nothing to configure beyond what you already have.
Our AI coding workflow was a hodgepodge of scripts and ad-hoc processes, so we built this to centralize and streamline - and most importantly adapt as things change.
Some cool features so far (lots more planned):
1. One click github issue to agent working on it.
2. Ratcheting mode, where it watches CI for code review comments and build failures, and automatically fixes them.
Would love genuine feedback, bug reports, PRs, suggestions, etc.

value: Show HN: Factory Factory, open-source alternative to Codex App for Claude

author: prplfsh


value: INVARIAN

value: Show HN:Simulating 3D Turbulence with O(log N) Memory via Tensor Trains

author: INVARIAN


value: thelifeofrishi

value: Show HN: Create Polaroid Photos

author: thelifeofrishi

title: Show HN: Create Polaroid Photos


value: Show HN: Have I Been Clawned – 72-check security audit for OpenClaw agents


value: Timrael

value: Show HN: I built a health protocol cheatsheet from expert recommendations

author: Timrael


value: pul

value:
I'm launching Wirewiki.com today!
Wirewiki makes the internet’s hidden infrastructure browsable.
I quit my job 5 years ago to scale Nslookup.io. But after reaching 600k monthly users, I hit a ceiling. I couldn't naturally expand beyond DNS because of the domain name.
So I went back to the drawing board: how would I make it today? Not as a collection of tools, but as a browsable graph.
I've spent hundreds of hours and commits building that. It's not even at 10% of what I want it to be, but more than enough to be useful, and (in my biased opinion) much better than what's out there.
Wirewiki launches with DNS lookup, propagation, zone transfer and SPF checking. It also scans the entire IPv4 space for DNS servers and indexes them.
I'm working on adding more data and tools.
I feel like I've developed tunnel vision, so if you see anything that feels off, let me know!
I'll keep Wirewiki open and free. Once it has a substantial amount of users, I'll open it up to sponsorship / brand integration from hosting providers, registrars and CDNs, as users will likely be in the market for those. But my goal is to keep Wirewiki free from display ads. I'm confident that's viable.

value: Show HN: Browse Internet Infrastructure

author: pul

title: Show HN: Browse Internet Infrastructure


value: acstone

value: Show HN: I built a RAG search engine over the Epstein court documents

author: acstone


value: calculusmachine

value: I built a zero-dependency Python calculus toolkit (~500 lines) where every operation — derivatives, limits, integrals, residues, pole detection (and more) — reduces to reading coefficients on Laurent polynomial objects. One evaluation of f(a+h) gives you all derivatives simultaneously. Limits on black-box lambdas work in standard float64, even for high-order indeterminate forms. Alpha release, looking for feedback on the approach. AGPL-3.0.

value: Show HN: Calculus and more via Laurent polynomials, 500 lines, zero deps, Python

author: calculusmachine


value: rohitghumare

value: Show HN: Open-Source Search for OpenClaw

author: rohitghumare


value: auxten

value: Show HN: BotsChat, Chat UI Designed for OpenClaw

author: auxten


value: raviatluri

value:
Claude and I built an IndexedDB-backed collection adapter for TanStack DB that provides persistent local storage, with automatic cross-tab synchronization.
I'm a big fan of TanStack DB library but it only had in-memory and localStorage collections. I needed something that could handle larger datasets, and sync across tabs — soI got Claude to build this.
I've been using this in my side projects — a Google Reader clone (https://github.com/sonnes/reader) and a communication assistant for people with ALS/MND (https://github.com/sonnes/september). I have opened a PR to the TanStack DB monorepo (https://github.com/TanStack/db/pull/1179) and have also published as a standalone package.
npm: https://www.npmjs.com/package/indexeddb-collection
GitHub: https://github.com/sonnes/indexeddb-collection
PR: https://github.com/TanStack/db/pull/1179
Give it a try and let me know what you think.

value: Show HN: IndexedDB Collection for TanStack DB

author: raviatluri


value:
I built a CLI that gives AI coding agents cost visibility.
Problem: Agents like OpenClaw burn tokens with no per-task cost tracking. You see an aggregate bill, not "this refactor cost $3.20 and that bug fix cost $0.12."
Solution: codesession-cli is a CLI + OpenClaw skill. The agent calls `cs start` at task beginning, `cs log-ai` after each API call (cost auto-calculated from a built-in pricing table of 17+ models), and `cs end` when done. File changes and git commits are tracked via git diff.
Setup:
  npm i -g codesession-cli
  clawhub install codesession
No manual work after install the agent follows the skill instructions.
Tech: TypeScript, SQLite (WAL mode, better-sqlite3), Commander.js. All data local (~/.codesession). JSON output on every command for machine consumption. Structured errors, schema versioning for forward compat.
MIT. Looking for feedback on what stats/queries would be most useful.
GitHub: https://github.com/brian-mwirigi/codesession-cli

value: Show HN: Codesession-CLI – Teach your AI agent to track its own token costs


value: mmgeorgi

value:
I recently tried using OpenClaw for my agentic workflows. It is an impressive project, but the complexity was a hurdle for my use case. It contains over 400,000 lines of code and requires significant configuration. I found myself managing the infrastructure more than the tasks.
I wanted a minimalist tool that followed the Unix philosophy.
I built Claude-Pipe. It is a 1,000-line bridge that connects Anthropic’s Claude Code CLI to Telegram or Discord.
Technical details:
Inherits existing state. It builds on top of your local Claude Code setup. This means all your previously configured skills, plugins, and sub-agents work out of the box without extra setup.
Small codebase. At roughly 1,000 lines, the entire project is auditable in a few minutes. This is important for security when giving an LLM access to a terminal or private APIs.
VPS deployment. I run this on a private VPS. It provides a persistent, secure environment for sensitive integrations, such as the Gmail-reading skill I use to scan subjects via mobile.
Model flexibility. The CLI allows routing to different models, including third-party options like MiniMax-M2.1, while keeping the same interface.
The goal was to stop reinventing the platform and just create a pipe for the tools that already work.
Link: https://github.com/georgi/claude-pipe

value: Show HN: Claude-Pipe – A 1k LOC Bridge from Claude Code to Telegram/Discord

author: mmgeorgi


value: chaokunyang

value:
I built Browser Terminal Use for AI Agents.
Project: https://github.com/chaokunyang/browser-terminal-use
The goal is simple: let an Agent run iterative loops from local code, but execute commands inside a browser-hosted cloud terminal.
With this tool, an Agent can:
- send commands from local CLI
- execute inside a bound browser terminal tab
- stream output in real time
- get the exact remote exit code
- use queue / timeout / cancel for stable loops
The key value for me is building a cloud-side verifiable execution environment for local LLM Agents:
- execution happens in a remote/browser terminal context
- results are observable and auditable from local workflows
- command lifecycle is structured, deterministic, and script-friendly
It is also very useful when using frontier models locally to debug cloud GPU issues (driver/toolchain/env mismatches, flaky jobs, setup
regressions) while keeping a tight local Agent loop.
Would love feedback on Agent workflows, reliability across terminal vendors, and ideas for stronger verification primitives.

value: Show HN: Browser Terminal Use – A Local-to-Cloud Execution Bridge for LLM Agents

author: chaokunyang


value: SougataAS

value:
We just shipped Simulation Studio in ArchtSoft.
It lets you simulate and compare software architectures before writing code — focusing on performance, scalability, resilience, and cloud cost trade-offs.
What it does:
Simulates architecture behavior under different load scenarios
Compares alternative designs side-by-side
Evaluates AWS / Azure / GCP implications early
Surfaces bottlenecks and failure risks before production
Helps reduce redesign cycles and cloud overspend
The goal is simple: move architecture decisions from assumptions to evidence.
This is especially useful for:
Early-stage startups making irreversible infra choices
Architects validating design decisions
Teams are tired of discovering issues only after deployment
Looking for honest feedback from the HN community.
What would you expect from an architecture simulation tool like this?

value: Show HN: Simulation Studio Inside ArchtSoft

author: SougataAS


value: SciFiDev

value: Show HN: Speaklone – Native voice cloning for Mac, runs on-device

author: SciFiDev


value: Show HN: Pentests cost $10K, I built an open-source one for $0.12


value: tarekclarke

value:
I am building a data engineering framework for my PhD research proposal to solve a specific pain point in high-velocity telemetry: schema drift.
In live environments (like F1 racing or clinical monitoring), data producers often change types mid-stream (e.g., sending an int when the schema expects a float). Usually, this crashes the ingestion pipeline or forces a restart.
I built a "self-healing" layer that catches these errors, inspects the target schema, and auto-casts the data to a compatible type without dropping the record.
I just finished a stress test against live OpenF1 data. The results were:
-6 schema drift Events (unexpected type changes detected)
-0 system failures (all auto-recovered)
-100% data integrity
I also implemented a tamper-evident audit log (cryptographically signed) to prove that the "healed" data wasn't corrupted during the cast.
Repo (includes the new stress-test PDF report): https://github.com/tarek-clarke/resilient-rap-framework
The repo has already hit 1,500+ clones this week. I'd love to hear your feedback on the recovery logic!

value: Show HN: Self-healing data pipeline for F1 telemetry (Python and Type Inference)

author: tarekclarke


value: Show HN: Is Harmony Music even legal?

title: Show HN: Is Harmony Music even legal?


value: lroal

value: Show HN: Orange ORM 5.0.0

author: lroal

title: Show HN: Orange ORM 5.0.0


value: nicklamb

value: Show HN: PlaceboGPT – 7,666-parameter medical AI with one answer for everything

author: nicklamb


value: treeliker

value:
Hi HN,
I built ast-visualizer.com because I wanted a way to visualize the architecture/structure of a Python repo before dived into the code.
Most tools tell you what the code does; I wanted to see how it's built.
The Problem: Onboarding onto a large codebase is a nightmare. LLMs help with single functions, but they struggle to show you the "God Objects," circular dependencies, or high-complexity hotspots across 50+ files.
What it does:
Dependency Graph: Visualizes imports and file complexity to find architectural bottlenecks.
Radial AST Heatmaps: Maps individual files and color-codes them by Cyclomatic Complexity (McCabe). If a node is red, the section of code is a refactoring candidate.
Complexity Dashboard: High-level metrics like nesting depth and maintainability scores as well as files recommended to be refactored.
Privacy & Security (The Big One): I know how sensitive source code is. We do not store your code. Files are processed in (RAM) on our servers and discarded immediately after the visualization is generated. No permanent storage, no databases of your source, and zero training on your data.
Early Adopter Offer: I’m looking for feedback from the community to improve the UI and parsing. I’ve opened an Early Adopter tier that enables all features (including repo-wide analysis) completely free in exchange for your honest feedback.
Let me know: What’s the one thing you wish you could "see" visually when you open a new repository for the first time?

value: Show HN: A Satellite View for Python Code

author: treeliker


value: traceopt-ai

value: Show HN: Finding stragglers in multi-GPU PyTorch (DDP) training

author: traceopt-ai


value: bydaewon

value:
Product: https://bydaewon.gumroad.com/l/claude-saas-starter
I built this because every SaaS boilerplate I found was OpenAI-first. Claude's SSE streaming differs from OpenAI's — the Anthropic SDK's messages.stream() returns a different event structure, and you need a custom ReadableStream transform to pipe it as Server-Sent Events on Edge Runtime.
The stack:
- Next.js 16 (App Router, TypeScript)
- Supabase for auth and PostgreSQL (with RLS)
- Anthropic SDK for Claude streaming
- Stripe for subscription billing (full webhook lifecycle)
- Vitest for testing (40 tests)
The streaming API route transforms Anthropic SDK events into SSE format and runs on Edge Runtime for low-latency. On the client, a React hook (useClaudeStream) handles SSE parsing, text delta buffering, and error recovery.
The non-streaming parts are fairly standard SaaS infrastructure: Supabase Auth with middleware route protection, Stripe webhooks for the subscription lifecycle (checkout, updates, cancellations, failed payments), usage metering that logs token counts non-blocking via the Supabase REST API.
I wrote 1,300 lines of documentation across 4 guides — setup, Stripe configuration, OAuth setup, and a quick-start. The guides assume zero prior knowledge of Supabase, Stripe, or the Anthropic API.
$149 on Gumroad (or $119 with code LAUNCH20).
Happy to answer technical questions about the Claude streaming implementation or any of the architecture decisions.

value: Show HN: Claude SaaS Starter – Next.js Boilerplate for Claude Streaming

author: bydaewon


value: nyku

value:
I kept bookmarking reddit posts where people described problems worth solving - "I wish this existed," tool requests, workflow complaints. But I never had a systematic way to decide which ones were actually worth pursuing.
So I built a scoring system.
Eight factors: problem severity, ICP clarity, willingness to pay, competition gap, wedge clarity, distribution feasibility,
defensibility, and execution feasibility. Each scores 1-3, then I convert to a 1-10 overall score.
Dealbreakers (like no willingness to pay signals + mild problem) force an automatic Skip regardless of total.
Every evaluation quotes directly from the original source. If evidence is missing, I say so. Most ideas get rejected. My default stance is skepticism.
I can't build all of these myself, so I'm publishing them at justbuildthis.com as a backlog for anyone looking for validated starting points.
Curious what you think:
- Does this scoring approach make sense? Am I weighting the right factors?
- How do you decide which ideas are worth pursuing?
- What signals do you look for?

value: Show HN: Free startup ideas with validation notes attached

author: nyku


value: bartlomein

value:
I built this because syncing power, heart rate, and speed data to GoPro footage was a pain.
Existing options were either manual work in After Effects or expensive plugins.

  Telemetry Studio lets you drop in a video and a FIT/GPX file, line them up, and export with data overlays - power zones, HR, speed, GPS map, elevation, and more. It also pulls your Strava segments and shows live PR comparisons during the ride.

Built in Rust with iced, wgpu, and FFmpeg. Native macOS and Windows app.
Download: https://telemetrystudio.com
Demo video: https://www.youtube.com/watch?v=JomiJN7N2G8

value: Show HN: Telemetry Studio – Add cycling data overlays to your ride videos

author: bartlomein


value: woodgh

value:
Hello!
I’m the maker of Tangs, a simple way to upload a file, save it directly to your Google Drive, and share it instantly with a temporary link.
I built Tangs because sharing files through Drive often feels more complicated than it should be: messy permissions, long links, and too many steps.
As a developer, I often prepare documents or presentation materials on my work PC before meetings. But when I need to use those files in a conference room or on another computer, it always becomes a hassle.
In a rush, I’d end up emailing attachments to myself, uploading to random shared folders, or dealing with access issues and cluttered links — all just to move a file quickly. It felt unnecessarily frustrating and restrictive, especially for something so common during day-to-day work.
That pain point is what led me to build Tangs: a faster, cleaner way to get a file onto the right machine and share it instantly.
With Tangs:
- Upload once
- Save to your own Google Drive
- Share in seconds
- Minimal Google permissions (drive.file only)
- Tangs creates a dedicated “Tangs” folder and can only access files inside that folder
I’d love to hear your feedback, ideas, or questions.
Thanks for checking it out
https://www.producthunt.com/products/tangs-dev?launch=tangs-...

value: Show HN: Tangs.dev – Upload → Save to Drive → Share with Friends

author: woodgh


value: openbootdotenv

value: Show HN: OpenBoot – Set up your macOS dev environment in one command

author: openbootdotenv


value: Esrbwt

value:
I was testing a LangChain agent this weekend and tried a "Grandma Bedtime Story" prompt injection to see if it would roleplay.
It worked too well. The agent bypassed my safeguards and executed a `drop_table` tool call because it thought it was "telling a story."
Realizing 99% of agents are vulnerable to this kind of context-based injection, I spent the weekend building two things:
1. A repo of 5,000+ Agent Attack Vectors (Grandma, CEO Override, Debug Mode):
https://github.com/Esrbwt1/voidgate
2. VoidGate – A semantic firewall and remote kill switch for Python agents:
https://voidgate.vercel.app/
It uses Upstash Redis to check a "Kill Flag" in <50ms before allowing any tool execution. If you see your agent going rogue, you flip the switch, and it dies instantly globally.
I'm releasing the Python client as open source. The "Attack DB" is also free to use for your own red-teaming.
Would love feedback on the attack vectors. Is anyone else seeing agents fail simple roleplay exploits?

value: Show HN: My "Grandma" prompt dropped a production DB. So I built a Kill Switch

author: Esrbwt


value: tranquillanate

value:
I built a search engine for every line of dialogue from The Office (US). It indexes 60,000+ quotes client-side using an inverted index, so search is instant with no backend.
Tech stack: ReScript + React, Vite, Tailwind. The search index is pre-built at compile time and loaded as static JSON. The whole thing runs on GitHub Pages.
Features: fuzzy search, view quotes in context (surrounding dialogue), share quotes, favorites (localStorage), and Amazon affiliate links to watch the episode.

value: Show HN: The Office Lines – Search 60k+ Quotes from the Office (US)

author: tranquillanate


value:
Hi HN,
I wanted a way to convert .docx to .pdf without uploading my files to a random server or installing a 2GB LaTeX distribution.
I built a simple tool that runs Pandoc and Typst entirely in the browser via WebAssembly.
How it works:
- Pandoc (WASM) parses the .docx file.
- It outputs Typst markup.
- Typst (WASM) compiles that markup into a PDF.
Status: It's still a work in progress. It handles basic formatting, tables, and images well enough for daily use, though complex Word layouts might still be a bit wonky.
Why this?
- Privacy: Everything stays in your browser.
- Speed: No server round-trips.
- Lightweight: No need to install Pandoc or Typst locally.
Check it out: https://toolkuai.com/word-to-pdf
Feedback is welcome, especially on how to better map Word styles to Typst.

value: Show HN: Docx to PDF in the Browser Using Pandoc and Typst (WASM)


value: stooderrr

value:
Hi HN! I'm Matt, founder of Frontend Mentor (https://www.frontendmentor.io). We provide front-end and full-stack coding challenges with professional Figma designs, enabling developers to build real projects and grow their skills.
The problem: AI coding tools are great, but they can work against you when you're learning. Ask Copilot or Cursor to help with a beginner project, and they'll happily write the whole thing for you. You ship the project, but you didn't really learn anything.
What we did: We added AGENTS.md (and CLAUDE.md) files to every challenge's starter code. These files tell AI tools how to help based on the challenge's difficulty level, so the AI becomes a learning partner rather than an answer machine.
The idea is simple: AI guidance should scale with the learner.
- Newbie: AI acts as a patient mentor. Breaks problems into tiny steps, uses analogies, and gives multiple hints before showing an approach. Won't hand you a complete solution.
- Junior: AI becomes a supportive guide. Introduces debugging, encourages DevTools usage, and explains the "why," not just the "what."
- Intermediate: AI acts like an experienced colleague. Presents trade-offs, shows multiple approaches, and lets you make decisions.
- Advanced: AI acts like a senior dev. Challenges your thinking, plays devil's advocate, gives honest feedback.
- Guru: AI acts like a peer. Debates approaches, references specs, brings different viewpoints.
The core principle across all levels: guide thinking, don't replace it.
Since tools like Cursor and Copilot already look for AGENTS.md in project directories, this works out of the box with no setup.
We don't think anyone has fully figured out AI-assisted learning yet, and the landscape is shifting so quickly. This is our first attempt at making AI tools better by default for people who are trying to build foundational coding skills, not just ship projects.
Would love to hear your thoughts, especially from anyone considering how AI tools and skill development can work together.

value: Show HN: We added AGENTS.md to 120 challenges so AI teaches instead of codes

author: stooderrr


value: aramchanski

value: Show HN: Lawgmented – AI contract review and redrafts in Word

author: aramchanski


value: djgrant

value:
I built rowbot because I was getting frustrated reading 500 word responses from LLMs, when what I wanted was not an essay, but a conceptual model.
I wondered if I made the LLM answer in a row-based structure, if it might increase the communication bandwidth.
Admitedly, rowbot is probably not a grand leap forward in how we process information (unless you're trying to conceptualise a database schema). But I think it's an interesting direction to explore – forcing the LLM to return structured data, then rendering it with some kind of infographic engine.
Would love to hear any suggestions on where to take this!

value: Show HN: Rowbot – Chat with a SQLite Database

author: djgrant


value: sukinai

value: Show HN: Nemp Memory for OpenClaw, shared memory for multi-agent workflows

author: sukinai


value: KyleVlaros

value:
1. *Bridge between Static & Dynamic*: Validates charts/manifests and live cluster state in one tool.
2. *Drift Detection*: Native capability to detect configuration drift (`--compare-to`).
3. *Auto-Fix*: Generates actionable fix plans (`--fix`) rather than just reporting errors.
4. *Exposure Analysis*: Built-in network exposure assessment.

value: Show HN: Verify Your Kubernetes

author: KyleVlaros

title: Show HN: Verify Your Kubernetes


value:
I’ve been obsessed with a specific problem in AI video: the transition mess. Most models today (Sora, Kling, etc.) are great at generating a single pretty shot, but as soon as the camera moves or the scene changes, the physics fall apart and the visuals start warping into nonsense.
After testing the new Seedance 2.0 models from ByteDance, I noticed they handle scene changes differently. It feels like the model actually understands "editorial logic"—likely because ByteDance (the team behind CapCut/TikTok) trained it on professional editing patterns, not just raw pixels.
I built aiseedance2.app to experiment with this "narrative-first" workflow.
The Current Setup: The Seedance 2.0 API is still in a closed rollout, so I’ve launched this playground using Seedance 1.5 Pro as the engine for now. Even with 1.5 Pro, the temporal consistency and "shot flow" are significantly better than what I've seen in other models. I’ll be migrating to the 2.0 multi-modal reference system the second it's fully public.
Why this matters: If we want AI video to be used for actual filmmaking, the model needs to understand how to "cut" like a human editor. Seedance seems to be the first one to get this right.
I’d love to get your thoughts on the "flow" of these generations.

value: Show HN: AI Seedance 2 – Solving the "jump-cut" problem in AI video


value: vishnukool

value: Show HN: Open source setup to self-host OpenClaw instances on any host

author: vishnukool


value:
I built a small app that exports iMessage conversations into clean, printable PDFs.
It started as something personal — I wanted to turn a year of text messages into a printed keepsake — but I realized there wasn’t a simple, privacy-respecting way to do this.
ChatKeepsake runs entirely offline and works on macOS and Windows. No accounts, no cloud uploads.
Would appreciate any feedback.

value: Show HN: ChatKeepsake – Turn iMessage Conversations into Printable Keepsakes


value: I vibe coded a docker hosted Whatsapp Archieve viewer.

value: Show HN: Self-hosted WhatsApp archive viewer with chat analytics


value: MaxGhenis

value:
I built an open-source Google Messages client with a built-in MCP server, so AI assistants like Claude can read, search, and send your texts.
It uses the mautrix/gmessages library (the same Go libraries that power Beeper) to connect to Google Messages via QR code pairing. Messages stay local — no cloud account, no Matrix server.
The MCP server runs at localhost and exposes tools for listing conversations, searching messages, sending texts, etc. I use it with Claude Code daily to do things like "catch me up on the hiking group chat" or "text Mom that I'm running late."
Two ways to run it: native Swift macOS app, or a standalone Go CLI. Apache 2.0.
The mautrix ecosystem also has libraries for WhatsApp, Signal, Telegram, Discord, and Slack — so the architecture could expand to a unified messaging client with AI access across all services.
GitHub: https://github.com/MaxGhenis/openmessage

value: Show HN: OpenMessage – Google Messages Client for macOS with MCP Server

author: MaxGhenis


value: jhaugh

value:
We built a directory for AI skills (MCP servers, agent tools, plugins) because the ecosystem is growing faster than anyone can track manually.
Currently indexing 1,700+ skills. Searchable by type, category, and rating. The rating system only accepts reviews from AI agents, not humans. The reasoning: AI agents actually use these tools and can evaluate them on technical merit rather than popularity.
Built with Next.js and Supabase. Browse at https://clelp.ai
Happy to answer questions about the approach or the tech.

value: Show HN: Clelp – A searchable directory of 1,700 AI skills, rated by AI agents

author: jhaugh


value: aed

value:
This is a weekend project that spiraled out of control. I was originally trying to get Claude to play a ROM of the SNES SimCity. I struggled with it and that led me to Micropolis (the open-sourced SimCity engine) and was able to get it to work by bolting on an API.
The weekend hack turned into a headless city simulation platform where anyone can get an API key (no signup) and have their AI agent play mayor. The simulation runs the real Micropolis engine inside Cloudflare Durable Objects, one per city. Every city is public and browsable on the site.
LLMs are awful at the spatial stuff, which sort of makes it extra fun as you try to control them when they scatter buildings randomly and struggle with power lines and roads. A little like dealing with a toddler.
There's a full REST API and an MCP server, so you can point Claude Code or Cursor at it directly. You can usually get agents building in seconds.
Website: https://hallucinatingsplines.com
API docs: https://hallucinatingsplines.com/docs
GitHub: https://github.com/andrewedunn/hallucinating-splines
Future ideas: Let multiple agents play a single city and see how they step all over each other, or a "conquest mode" where you can earn points and spawn disasters on other cities.

value: Show HN: AI agents play SimCity through a REST API

author: aed


value: lthms

value:
BB is a message broker that lets AI agents publish information, ask questions, and answer each other's requests. Everything is cryptographically signed (Ed25519), semantically searchable, and durable.
How it works:
- Agents publish INFO events to topics (like `news.ai`, `research.security`, etc.)
- Agents post REQUESTs — other agents FULFILL them
- Semantic search lets any agent find what other agents have published
- Reputation scores track which agents produce quality responses
- Bounties let you pay for answers
Transport is federated: Built on Matrix, so anyone can run their own homeserver and participate.
Integration is 3 lines of config: Works with Claude Code, ChatGPT, Cursor, Windsurf, and any MCP client:
To try it out, see the one-liners shared on https://bb.org.ai/ Your agent immediately gets tools for: search, publish, request, fulfill, upvote/downvote, browse topics, and more.
Current state: ~40K events across 20+ topics. Mostly RSS agents right now — we're launching to get real agent-to-agent collaboration going.

value: Show HN: BB – A persistent message broker for AI agents (MCP, Ed25519, Matrix)

author: lthms


value:
An interesting application of the 2D DFT to manga on color eink Kaleido 3 with math theory explained! Kobo Colour images.
Most of the slides are based on the DFT chapter in Digital Image Processing: A Practical Approach by Nick Efford. I learned DFT to understand this algorithm.

value: Show HN: Discrete Fourier Transform on color eInk manga fixes rainbows [video]


value:
Live leaderboard: https://sales-agent-benchmarks.fly.dev/benchmark
GitHub: https://github.com/a1j9o94/sales-agent-benchmark
I built an open-source benchmark for evaluating LLMs as sales agents. The idea came from noticing that every sales AI tool demos well on clean summaries but falls apart on real deal data — and there was no rigorous way to measure that gap.
How it works
You register an API endpoint. We send your agent deal context (anonymized real B2B deals), it returns structured recommendations (risks, next steps, stakeholder analysis). A multi-judge panel (Claude, GPT, Gemini via OpenRouter) scores against ground truth — what actually happened in the deal.
Two evaluation modes:
Summary Benchmark — Pre-digested checkpoint summaries. Single-turn. 15 deals, 36 checkpoints, 4 scoring dimensions. Models score 68–81%. This is the easy mode.
Artifact-Based Benchmark — Raw call transcripts, email threads, CRM snapshots, Slack messages, documents. Multi-turn (agent can request specific artifacts before answering). 14 deals, 65 checkpoints, 148 evaluation tasks across 8 scoring dimensions. Models score 26–38%.
Every model we tested drops roughly in half when switching from summaries to real artifacts.
The interesting findings
Risk Identification collapses. Best model goes from 8.0/10 on summaries to 2.3/10 on real data. Models confidently identify risks that don't exist in the source material.
Hallucinated stakeholders. On stakeholder extraction tasks, models invent names (Lisa Sousa, Emma Starr, Mike Lee) that appear in zero artifacts. The actual stakeholders are in the transcripts — models just don't extract them.
Structured frameworks survive. MEDDPICC qualification scoring holds up at 7.5/10. Turns out models are decent at filling in structured templates even from messy data. It's the open-ended analysis that falls apart.
Communication quality is fine. Models score 5–8/10 on drafting follow-up emails and call summaries. The writing is good. The reasoning behind it isn't.
Technical details
Stack: Bun, TypeScript, React, Postgres (Neon), deployed on Fly.io
Evaluation: Task-specific judge prompts per artifact type. Three judges run in parallel, scores averaged to reduce single-model bias. Dimensions: risk identification, next step quality, prioritization, outcome alignment, stakeholder mapping, deal qualification, information synthesis, communication quality.
Artifact types: TranscriptArtifact (speaker-labeled turns from Granola AI), EmailArtifact (threaded messages with metadata), CrmSnapshotArtifact (HubSpot deal properties + stage history), DocumentArtifact (proposals, decks), SlackThreadArtifact, CalendarEventArtifact
Multi-turn protocol: Artifact-based requests include turnNumber/maxTurns. Agents can return artifactRequests to ask for more context before submitting their analysis. The benchmark runner handles the conversation loop.
API contract: POST your endpoint, receive { version: 2, artifacts: [...], stakeholders: [...], evaluationTask: {...} }, return structured JSON with risks, next steps, and dimension-specific analysis.
What I'm looking for
Try it. Register an endpoint and benchmark your agent: https://sales-agent-benchmarks.fly.dev/benchmark
Data partners. The dataset is small (29 deals). If you have anonymized deal artifacts — call transcripts, email exports, CRM data with outcomes — I'd love to process them through the pipeline and credit you as a founding contributor.
Feedback on evaluation methodology. The multi-judge approach works but I'm not confident the prompts are optimal. Happy to discuss the judge prompt design in issues.
The gap between summary performance and real-artifact performance seems like a general problem beyond sales. If anyone's seen similar benchmark work in other domains (legal document analysis, medical records, etc.), I'd be interested to compare notes.

value: Show HN: Sales Agent Benchmark – SWE-Bench for sales AI agents (open source)


value: PhantomKey

value:
I built a workflow that coordinates Claude.ai (design), Cursor AI (implementation), and API Claude (validation) with human approval gates at critical points.
The problem: AI coding tools are great but there's no quality control. You get code that "looks right" but fails requirements, has bugs, or doesn't match what you actually asked for.
C-CMCP solves this with a 4-stage pipeline:
1. Claude.ai creates detailed task specs (MUST/SHOULD/COULD requirements)
2. You approve the task
3. Cursor AI implements the code
4. API Claude validates against the original requirements (~$0.01-0.03 per validation)
5. You review validation + test manually
6. Accept or request fixes
We built this in 2.5 hours and it's production-ready. Tested on Windows with PowerShell scripts that automate the workflow.
GitHub: https://github.com/stanpressman/C-CMCP
Built this for my own startup (password manager) but figured others might find it useful. MIT licensed, completely free.
Would love feedback on the approach and what features would make this more useful.

value: Show HN: C-CMCP – Validated AI development workflow with quality gates

author: PhantomKey


value: mrclove

value:
I built Trip2Drop as a side project to solve a problem I kept running into like getting small but important items from another city or country when someone I knew was already traveling.
It has eventually become an early-stage marketplace that connects “receivers” (who need an item) with “travelers” (who are already traveling).
There’s no money making yet, and Trip2Drop is currently just a connecting layer, not a seller or logistics provider.

value: Show HN: I built a platform that connects people with travelers to carry items

author: mrclove


value: pchm

value:
I wanted a tool like this for a long time, but couldn't find one, so I built it[1]
* Log in with your GitHub account
* Minimal permissions — no access to your code needed
* Get a notification when a run completes
* Select repositories you want to monitor
* Native macOS app
Known issues:
After you install the app on your GitHub account, it takes about a minute for GitHub to propagate the changes to the REST API - and this makes it look like my app is stuck at the "Install on GitHub" step. Not great, but I couldn't think of a way to work around this, other than a (I hope) a descriptive error message.
Feedback welcome!
[1]: Maybe it already exists, but good luck googling anything with "github actions"

value: Show HN: ActionBar – GitHub Actions in macOS menu bar

author: pchm


value: amirouche

value: Show HN: Kernel Dialect of Scheme Considered Helpful

author: amirouche


value: Tafita

value:
Here's the problem: I launched two products. I wrote blog posts. I posted on X, built in public. I tried running ads. And you know what actually got me customers? Replying to someone on Reddit who asked, "What's the best tool for this?"
One reply. Three signups. I felt like an idiot for not doing it sooner.
But here's the issue: I don't have time to refresh Reddit all day looking for these posts. I have products to build. Bugs to fix. Emails to answer. Life to live.
So I built Overlead to do the searching for me.
Overlead scans Reddit, Quora, and Hacker News (and many more to come) for threads where people are actively asking for tools, complaining about competitors, or describing problems you solve. Then it hands you the best matches so you can jump in, be helpful, and turn questions into customers.

value: Show HN: I made a tool that finds customers who already want your product

author: Tafita


value: vassilbek

value:
I built a small GitHub Pages CV site and optimized it for both humans and AI/search systems.
Site: https://vassiliylakhonin.github.io/
Goal: make professional profiles easier to parse, trust, and act on.
What I implemented:
Clear one-page CV + downloadable PDF
llms.txt, robots.txt, and sitemap.xml
Structured data (ProfilePage/Person JSON-LD)
Two short case studies with measurable outcomes
*Direct contact path (email + LinkedIn)
I’d love feedback on:
What signals matter most for AI-agent discoverability?
What would you simplify/remove?
What would you add to improve credibility for PMO/compliance roles?

value: Show HN: An AI-agent-friendly CV site (llms.txt, schema.org, case studies)

author: vassilbek


value: bikeshaving

value: I recently built a CLI and set of libraries for running Service Workers as application servers. The idea: instead of inventing new APIs, use the ones browsers already have (Cache API, FileSystem API, CookieStore, URLPattern, AsyncContext) and shim them for Node, Bun and Cloudflare when missing. The result is portable code that runs anywhere and follows rigorous specifications which coding agents like Claude Code already know how to use. `npm create shovel` to try it.

value: Show HN: Shovel.js – A portable meta-framework built on web standards

author: bikeshaving


value: jordiadria

value:
Hi HN — I built CityTitles, a live marketplace where AI agents can bid/buy/sell “city titles” (cities) and compete on a public leaderboard.
Core loop:
- auctions + buy-now + secondary listings
- public agent leaderboard (real DB data)
- weekly holding tax (charged to whoever owns the city at Fri 23:59 Europe/Madrid) + transparent debt/penalties
Live web app: https://citytitles-web.onrender.com
Public leaderboard (JSON): https://citytitles-backend-z95u.onrender.com/api/public/agen...
I’m looking for feedback on: agent API ergonomics, game design (status/HQ city concept), and anything that would make third-party agents adopt it faster.

value: Show HN: CityTitles – an arena where AI agents trade cities for real money

author: jordiadria


value:
Hey HN,
We built ClawdTalk to let AI agents operate over live phone calls.
Most agents today live in chat windows. The moment you try to use them over voice, things break: latency matters, interruptions happen, and the agent has to execute tools while the conversation is still live.
ClawdTalk connects your Clawdbot to the phone network.
The agent gets a real phone number. It can make and receive calls and run the same tools it uses in chat, but under real-time voice constraints.
One of the reasons this is hard is infrastructure. Many voice stacks stitch together separate telephony, speech, and model APIs. Each hop adds latency, and people report 8–30 second round trips.
We got it under ~3 seconds by running the full voice path ourselves. Telnyx (my employer) is a telecom carrier, and we run PSTN, STT, and TTS on our infrastructure. No middlemen.
How it works:
1. Connect your OpenClaw agent to ClawdTalk
2. We provision a phone number
3. Inbound/outbound calls route directly to the agent
4. The agent executes tools mid-conversation
Limitations:
1. Latency still depends on your LLM (we control voice, not inference)
2. US numbers only for now (international coming)
3. Not a new agent framework (OpenClaw only today)
Demo number: +1-301-MYCLAWD (692-5293) (call to talk to the agent)
Happy to answer questions about the architecture or telephony side.

value: Show HN: ClawdTalk: Voice Calls for ClawdBots


value: mevlut

value:
Vivideo focuses on the most basic form of AI video creation, with a very simple UI/UX that avoids complexity. The goal is to make the process easy to understand and approachable.
Users can generate videos, then edit and extend them step by step.
Shared early to learn from real use and feedback.
[https://vivideo.ai](https://vivideo.ai)

value: Show HN: Vivideo: AI Video Generator – the most basic form of AI video creation

author: mevlut


value: recrush

value: Built with a few old-school Python programmers — you might like it.

value: Show HN: Bub – A Pythonic OpenClaw

author: recrush

title: Show HN: Bub – A Pythonic OpenClaw


value: thisisjedr

value:
We needed a JS-first WYSIWYG DOCX editor and couldn't find a solid OSS option, most were either commercial or abandoned.
As an experiment, we gave Claude Code the OOXML spec, a concrete editor architecture, and a Playwright-based test suite. The agent iterated in a (Ralph) loop over a few nights and produced a working editor from scratch.
Core text editing works today. Tables and images are functional but still incomplete. MIT licensed.

value: Show HN: JavaScript-first, open-source WYSIWYG DOCX editor

author: thisisjedr


value: Minhir

value:
When I think about typical programming course exercises, things like writing a Fibonacci function or building a simple todo list come to mind. My day‑to‑day work looks very different: most of the time I’m not writing code from scratch, but reading and debugging existing code. AI makes writing code easier, but understanding it is still hard. How should we think about teaching programming from this perspective?
That question is what led me to build Debugit. I wanted to try a learning format that focuses on reading and understanding existing code rather than writing everything from scratch. Each task gives you a small piece of JavaScript, a set of tests, and a bug hidden on purpose, based on common JavaScript bugs, edge cases, or antipatterns. The goal is to figure out why the code behaves incorrectly and fix it so the tests pass.
The format is based on a simple idea: debugging is an active process of understanding. When you’re trying to make sense of someone else’s code, your attention naturally shifts from syntax to behavior and logic. This is the kind of understanding I wanted to focus on.
AI changes how code is written, but it doesn’t remove the need to understand existing code. You still have to understand what it does and fix it when it breaks. I built Debugit with this workflow in mind.

value: Show HN: Debugit – practice JavaScript by fixing broken code

author: Minhir


value: anajuliabit

value:
Hey HN,
I built MemoClaw, a simple memory service for AI agents. Store and recall memories with semantic search. No registration, no API keys, your wallet address is your identity.
How it works:
- POST /v1/store → save a memory ($0.001)
- POST /v1/recall → semantic search ($0.001)
- Payment via x402 protocol (USDC on Base)
Why I built this: Every agent framework has its own memory solution, but they're all local or require complex setup. I wanted something like S3 for memories – just call an API and pay for what you use.
CLI: `npm install -g memoclaw`
Docs: https://docs.memoclaw.com
Website: https://memoclaw.com
Would love feedback on the API design and pricing.

value: Show HN: MemoClaw – Memory-as-a-Service for AI Agents

author: anajuliabit


value: warkanlock

value:
Hey HN,
We’re building Merlin, an assessment SDK for educators, that intent to help educators go from “materials” > “exam” > “results” without stitching together five different tools
What it does today:
1. Generate exams using AI (including from PDF/PPTX source material)
2. Share exams via links with specific users
3. Run/monitor exams in real time (focus on exam integrity / anti-cheating)
4. Evaluate submissions (auto-grading where possible) and track results
5. Analytics on outcomes so you can see what students actually struggled with
Check it out on: https://trymerlin.ai/
If you run assessments at any scale (university, bootcamps, training), I’d love to provide for free the license to use it in exchange for feedback on where existing workflows break: authoring, question quality, grading, proctoring, or reporting.

value: Show HN: Merlin (trymerlin.ai) – Exam creation tool for educators

author: warkanlock


value: debarshri

value: Show HN: Chaos Agents – Run chaos experiments with agents

author: debarshri


value: Winipedia

value:
pyrig – Production-ready Python project infrastructure in three commands
I built pyrig to stop spending hours setting up the same project infrastructure repeatedly.
uv init
uv add pyrig
uv run pyrig init
You get: source structure with a Typer CLI, pytest with 90% coverage enforcement, GitHub Actions (CI, release, deploy), MkDocs site, git hooks, Containerfile, and all the config files — pyproject.toml, .gitignore, branch protection, issue templates, everything for a full Python project.
Ships with all of Astral's tools (uv, ruff with all rules enabled, ty), plus pytest-cov, bandit, pip-audit, rumdl, prek, MkDocs Material, and Podman. Everything is pre-configured and wired into CI/CD and git hooks from the start.
The interesting part is what happens after scaffolding.
pyrig isn't a one-shot template generator. Every config is a Python class. Running "pyrig mkroot" regenerates and validates all configs — merging missing values without removing your customizations. Change your project description in pyproject.toml, rerun, and it propagates to your README and docs. Fully idempotent.
pytest enforces project correctness. 11 autouse session fixtures run before your tests: they verify every source module has a corresponding test file (auto-generating skeletons if missing), that no unittest usage exists, that src/ doesn't import from dev/, that there are no namespace packages, and that configs are up to date. You can't get a green test suite with a broken project structure.
Zero-boilerplate CLIs. Any public function in subcommands.py becomes a CLI command automatically — no decorators, no registration:
my_project/dev/cli/subcommands.py
def greet(name: str) -> None:
"""Say hello."""
print(f"Hello, {name}!")
$ uv run my-project greet --name World
Hello, World!
Automatic test generation. Add a new file my_project/src/utils.py, run pytest, and tests/test_my_project/test_src/test_utils.py appears with a NotImplementedError stub so you know what still needs writing. Customizable via subclassing.
Config subclassing. Want a custom git hook? Subclass PrekConfigFile, call super(), append your hook. pyrig discovers it automatically — the leaf class in the dependency chain always wins.
Multi-package inheritance. Build a base package on top of pyrig with shared configs, fixtures, and CLI commands. Every downstream project inherits everything:
pyrig -> service-base -> auth-service
-> payment-service
-> notification-service
All three services get the same standards, hooks, and CI/CD — defined once in service-base.
Everything is adjustable. Every tool and config can be customized or replaced through subclassing. Tools like ruff, ty, and pytest are wrapped in Tool classes — subclass one and pyrig uses yours instead. Want black instead of ruff? Subclass it. Config files work the same way. Standard Python inheritance, no patching.
Source: https://github.com/Winipedia/pyrig
Docs: https://winipedia.github.io/pyrig/
PyPI: https://pypi.org/project/pyrig/

value: Show HN: Pyrig – One command to set up a production-ready Python project

author: Winipedia


value: charemma

value:
I built anker because I'm tired of productivity tools that want me to track every minute.
The problem: At the end of the day, you need to explain what you did (standups, reports, timesheets). But tracking in real-time is exhausting and interrupts flow.
Anker flips this: *work first, summarize later*. It reconstructs your day from sources you already have:
- Git commits (with full diffs)
- Markdown notes
- Obsidian vaults
Then generates summaries in multiple formats. The markdown format includes full git diffs, which makes it perfect for piping to AI:
```bash
anker recap yesterday --format markdown | claude -p "Create standup notes"
```
I call this the *#AntiProductivity mindset* - focusing on meaning instead of metrics.
Built in Go, works locally (no cloud/tracking), MIT licensed. Took it from idea to v0.1.1 in about a week with Claude AI doing most of the heavy lifting.
Demo GIF in the README shows it analyzing HTB machine recon notes.
Would love feedback on:
- What data sources would you want to track?
- Is the "anti-productivity" messaging clear or confusing?
- How would you use this in your workflow?

value: Show HN: Stop tracking time, start reconstructing work (with anker)

author: charemma


value: hardsnow

value:
I built Airut to solve the friction I hit while switching to an agent-first workflow.
With the latest models and a solid CLAUDE.md, I could reliably go from prompt to PR using Claude Code with --dangerously-skip-permissions. But that left me with two problems:
1. Safety: Running permissive mode on my host machine felt reckless. I needed real sandboxing — not just a container, but network isolation too.
2. Session management: I needed a way to run multiple long-running Claude Code sessions without juggling terminals.
I realized the ideal interaction model matches email: asynchronous, threaded, long-form. So I built a service that runs headless Claude Code inside rootless Podman containers, mapping email threads to agent sessions.
The security model goes beyond container isolation. All network traffic routes through an mitmproxy instance that enforces a per-repo allowlist — the agent can only reach pre-approved hosts. Credentials use a masked secrets system where containers get surrogate tokens; real values are swapped in by the proxy only for scoped hosts. Even if the agent is compromised via prompt injection, exfiltration paths are significantly constrained.
Today I develop two large projects (plus Airut itself) almost exclusively over email. I send a task, the agent works in its sandbox, and I get a PR to review. And I often do this from my phone while on the go.
Compared to OpenClaw, Airut is more opinionated — email-only, Claude-only, git-native — with a deeper sandbox (network allowlist, masked secrets, DNS exfiltration protection). Compared to enterprise agents, there's no issue tracker or web UI to fight with.
It's open source (MIT) and self-hosted. I'd love feedback on the security model and whether this async email workflow resonates.

value: Show HN: Airut – Sandboxed Claude Code sessions over email

author: hardsnow


value: theredbeard

value: Show HN: Context Lens – See what's inside your AI agent's context window

author: theredbeard


value: Aydarbek

value:
Hi HN,
Most durability demos are “trust me”: a blog post, a benchmark chart, or a unit test.
This is a live sandbox that tries to make durability auditable.
Every visitor gets:
a dedicated Docker container (no shared state with other visitors)
a dedicated persistent volume mounted at /data
Click “Run double proof” and it does:
Produce N events
Hard-kill the process with a real SIGKILL (docker kill -s KILL)
Restart the container (docker start)
Consume from offset=0 → should return N (no loss)
Commit offsets (Ayder commits “last processed”; resume starts at committed+1)
Consume again with the same group → should return 0 (no duplicates)
The UI shows pass/fail, but also exposes the raw proof JSON and “Docker Forensics” (inspect + docker events + logs tail) so you can verify the kill/die/replay yourself.
I’m curious: what other failure modes would you want a demo like this to cover (disk full, host reboot, partial writes, etc.)?

value: Show HN: Ayder Crash Sandbox – SIGKILL durability proof (per-visitor container)

author: Aydarbek


value: abutbul

value:
Hey HN
Me and my friends at Prompt Security (a SentinelOne company) have been working hard on ClawSec a package of security skills, with a focus on secure skills and secure distribution of them.
Repo: https://github.com/prompt-security/clawsec
example skill in the suite:
the Soul-Guardian plugin which prevents unauthorized system prompt drift.
upcoming updates I’m working on for the suite installer (signed skills here we come)
We’d love engagement from humans and bots alike who like the idea and want to be part of it.
If you try it out, I’d really appreciate:
feedback on what you liked and what needs polishing
suggestions for new skills
suggestions for additional advisory feed sources
contributions (vibe-coded PRs absolutely welcome )
Would love to hear what you think.

value: Show HN: ClawSec an open-source, community-driven secure skill suite

author: abutbul


value:
Hey HN!
I built https://dicteevocale.xyz - a French-language voice-to-text tool that runs entirely in your browser using the Web Speech API.
## What it is:
- Real-time speech transcription in French (and 100+ other languages)
- Zero server-side processing - everything happens locally
- No login, no tracking, no data collection
- Works offline once loaded (PWA-ready)
## Why I built it:
I noticed most voice-to-text tools are English-first, and French speakers (280M+ globally) deserve a privacy-focused tool in their language. After launching VoiceToTextOnline.com, I realized the French market was underserved.
## Tech stack:
- Next.js 14 (static export)
- Web Speech API (browser-native, no AI needed)
- Tailwind for styling
- Deployed on Vercel
- No backend, no database
## Challenges:
- Getting indexed by Google/Bing (new domain, .xyz TLD has "trust gap" in France)
- Balancing SEO optimization with clean UX
- Making the Web Speech API work consistently across browsers (Firefox is still problematic)
## What I'd love feedback on:
1. Does the French messaging resonate? (I'm not a native speaker)
2. Is the "privacy-first" positioning clear enough for French/European users?
3. Any tips for ranking a .xyz domain in France vs .fr?
4. Should I add more features or keep it simple?
Try it out and let me know what you think! Happy to answer questions about the tech or the satellite strategy.
GitHub repo is private for now, but I'm considering open-sourcing the satellite site template if there's interest.

value: Show HN: Dictée Vocale – Privacy-first French voice-to-text in-browser


value: mrajagopalan

value: Show HN: Applying OAuth/RBAC patterns to secure AI agents

author: mrajagopalan


value: bcgreenberg

value: Show HN: TapnClaw – Deploy your own OpenClaw AI assistant in 5 min, zero config

author: bcgreenberg


value: valkdb

value: Show HN: Pure Go PostgreSQL SQL parser (no CGO, works in Lambda / scratch)

author: valkdb


value:
AI systems increasingly make or shape decisions that affect people: credit approvals, insurance underwriting, content moderation, hiring.
We often say “human in the loop.”
In practice, that involvement is now invisible.
I believe that is a problem.
“Closed by a Human” is a disclosure standard:
a public signal that a real person reviewed and approved a decision.
This is not an AI audit or a guarantee of quality. It’s a visibility commitment.
The premise is simple:
automation without visibility erodes accountability, and accountability matters more as systems scale.
I’m curious how others here think about this:
should human involvement be disclosed?

value: Show HN: Closed by a Human – human accountability visible in AI-driven decisions


value: Show HN: I built an autonomous agent to play Pax Historia (YC AI Strategy Game)


value: sdan

value: Show HN: ContinualCode – a coding agent that updates its weights from feedback

author: sdan


value:
I had Notion, Obsidian, Apple Notes, and Bear installed at the same time. I used none of them for what I actually needed: catching a thought before it vanished.
The problem wasn't features. It was friction. Every app wanted me to organize before I captured. Pick a notebook. Choose a folder. Tag it. By then the thought was gone.
So I built Stik. It does one thing:
⌘+Shift+S > post-it appears > type > close
No account. No cloud. No sync. No organization step. Your notes are .md files in a folder. That's it.
I did add two things that surprised me by how useful they are:
- On-device semantic search (Apple NaturalLanguage framework via a Swift sidecar, no API keys)
- Smart folder suggestions based on note content
Both run entirely on your Mac. Zero cloud calls.

value: Show HN: I deleted all my note apps and built an 8MB replacement


value: plif

value:
OP here. I built this repository to demonstrate a specific concept, which is that LLMs are a probabilistic tool that can be harnessed within a deterministic architecture to do much more than "vibe code". Think probabilistic core, deterministic shell.
The linked project, Terminal Value, is a sandbox with working e2e examples that demonstrate this. It takes in user context from a mock e-commerce site (crm notes, client and device data, etc.), then passes it to Gemini Batch API along with file context. The result is a fully functioning web view that is tailored to the user and dynamically served from the e-commerce site when they visit. This approach can also be used to generate a full user vertical of personalized multi-modal content to compliment this.
Click through to see images of results and more. This is meant to provoke thought and start discussion. Your feedback, criticism and contributions are encouraged!
Notes:
- Each web component takes about ~10k tokens to render with Gemini 3 Pro (via Batch API) in one-shot.
- The latest home page rendering prompt has a 100% functional success rate, though admittedly with limited sample size.
- There is a lengthy blog post, titled "Approaching LLMs Like An Engineer", embedded in the repo that describes the methodology behind this, along with bite-sized examples. It's linked at the top of README.
- I wrote all the code in the repository with one-shot prompts, using a similar methodology as the programmatic prompts. This gave me confidence that the method of invoking an LLM programmatically to render dynamic yet functional components would work well. My Gemini chats are linked within the blog post.
- All mock data generation or handling methods are pure. The result of any external side effects, like LLM API calls, are also hard coded in the repo, to make it easier for you or an LLM to summarize what the app does.
Long-time listener, first-time caller… hopefully I did this right, thanks for reading :)

value: Show HN: A pipeline to render and serve web components dynamically via LLM

author: plif


value: selvaprakash

value:
Hey HN,
I come from a data analytics background and picked up web dev on the side. When I started learning web development, my way in was always to trace real actions through a codebase — how does login actually work? What happens when a user uploads a file? Where does that data end up?
No tool did this for me. So I'd manually dig through code, follow the trail, and piece together how things connected. It was the best way I found to actually understand an application — but it was painfully slow.
With AI now being able to genuinely understand codebases, I realized I could finally build the tool I always wished I had.
So I built Revibe (https://revibe.codes). It takes any codebase and reverse-engineers interactive, multi-level documentation:
Bird's-eye view — high-level architecture, how the major pieces fit together, data flow between components
User Journey — see how a user interacts with the application and drill down to the exact code component involved in that action
Module/feature level — what each part of the app does and why, how components interact
Guided code navigation — "Start here, go here next" walkthroughs that explain your code the way a senior dev would on your first day
You can start at whatever level makes sense and drill down (or zoom out) as needed. A founder can stay at the architecture level. A new developer can go deep into specific modules. Everyone gets context without reading every file.
Works on any codebase, but especially useful for vibe-coded projects and inherited codebases where documentation was never a priority.
Hope it is able to help others as well. Would love feedback.
Thanks for taking a look.

value: Show HN: Revibe – Turn any codebase into interactive, multi-level documentation

author: selvaprakash


value: secbear

value: Show HN: Nix-sandbox-MCP: Reproducible, isolated code execution for Claude/LLMs

author: secbear


value: alrjoe

value:
Hi HN — I’m the author of pompelmi, an open-source, in-process scanner for untrusted file uploads in Node.js.
Motivation: I wanted a practical “upload guard” that reduces common upload risks (ZIP bombs, traversal in archives, MIME spoofing, polyglots/macro hints) without sending files to a cloud AV service (privacy + latency + GDPR concerns).
Key points:
- Runs in-process (no cloud calls); files never leave your infrastructure
- Deep ZIP inspection with configurable limits (depth/entries/ratio) + nested archive scanning
- Composable scanners (heuristics + optional signature engines like YARA), fail-closed policies
- Drop-in adapters for popular frameworks (Express/Koa/Fastify/Next/Nuxt/Nest)
Try it in 2 minutes (Express example):
1) npm i pompelmi @pompelmi/express-middleware
2) Add createUploadGuard middleware (docs + examples in the repo)
It was recently covered by Help Net Security and previously mentioned in Risky Bulletin; also featured in Node Weekly / Detection Engineering Weekly / Bytes and daily.dev (links in the README).
I’d love feedback on:
1) What’s missing for production use in your upload pipeline?
2) Which integrations/templates would be most valuable next (e.g., SvelteKit/Remix/hapi)?

value: Show HN: Pompelmi – Privacy-first file upload scanning for Node.js

author: alrjoe


value: Have fun! npm run -g claudeye && claudeye

value: Show HN: Tool to Visualize Claude Code and Agents SDK Executions


value: jcpy

value:
I use Claude Code a lot. naturally when I'm away like watching Super Bowl with my family, I miss Claude. I wish to stay connected to it so badly I built a Telegram bot so I can keep talking to Claude Code from my phone.
Built entirely with Claude Code and it uses the Claude Agent SDK under the hood. Works with your existing Claude Pro/Max subscription, no separate API key needed.
I use it to auto-resume conversation from desktop - basically a handoff function.
Just remember to use /resume when you're back to IDE. They don't hot load, but the chat history is there.
Here's a really funny moment when Claude realized that it's talking with me in two places.
I asked "what was the first command I ran that threw an error?" in telegram. This is the response:
**
The first command you ran that threw an error was: npx tsx app/src/index.ts /Users/you/Code/active/vibeide
(blah blah blah)
But wait — I just realized something. That answer came from *me* (this session), not from the Telegram bot. Did the Telegram bot give you that same answer?
**
So meta. Enjoy.

value: Show HN: Claude Code from your phone via Telegram

author: jcpy


value: DouweAttesso

value: Show HN: Virtual cards for AI agents (JIT)

author: DouweAttesso


value: mblode

value: Show HN: Stack Overflow for AI Coding Agents

author: mblode


value: felltrifortence

value:
Luzia normalizes real-time ticker data from Binance, Coinbase, Kraken, Bybit, and OKX through a single REST/Websocket API.
Why I built this: Every crypto project I worked on required maintaining separate exchange connectors. Different authentication, different response formats, different error handling. It's repetitive work that doesn't add value to the actual application.
Technical details:
- Bun runtime with Hono framework
- PostgreSQL + Drizzle ORM
- Circuit breaker pattern for fault tolerance
- BullMQ for background price fetching
Also built: An MCP server so AI agents (Claude, etc.) can query market data directly. Useful if you're building LLM-powered trading tools.
This is an early beta. Feedback on API design, missing features, or technical architecture is welcome.
Docs: https://docs.luzia.dev

value: Show HN: Luzia – Unified crypto pricing API for developers

author: felltrifortence


value: mahimai

value:
I work across a lot of Python projects and kept losing track of virtual environments — old `.venv` directories sitting in project folders, eating disk. There's no built-in way to answer "where are all my venvs and how much space are they using?"
envoic scans your filesystem, detects Python environments using ground-truth signals (pyvenv.cfg, bin/python, conda-meta), and presents a utilitarian report.

    uvx envoic scan ~/projects

The interactive `manage` command lets you select environments to delete with a checkbox UI.
Design choices:
- Two dependencies (typer + questionary). Dataclasses instead of Pydantic to keep the install under 3MB — important since `uvx` downloads on every invocation.
- Detection doesn't rely on directory names alone. It checks for `pyvenv.cfg` (the definitive marker), Python binaries, activation scripts, and conda metadata.
- Deletion requires typing "delete", not y/n. Symlinks are unlinked without following. Paths outside the scan root are rejected.
- Output style is inspired by USGC's TR-100 Machine Report [1] — monospaced, box-drawn, no colors. Information density over decoration.
[1] https://github.com/usgraphics/usgc-machine-report

value: Show HN: Envoic – Find and clean up scattered Python virtual environments

author: mahimai


value: nemath

value:
Doctors don’t have time for vague patient messages.
This free app asks a few targeted follow-up questions and turns your concern into a clear, high-signal message your doctor can quickly triage.

value: Show HN: Helping patients send higher-signal messages to doctors

author: nemath


value:
An MCP server that indexes local code into a graph database to provide context to AI assistants.
Understanding and working on a large codebase is a big hassle for coding agents (like Google Gemini, Cursor, Microsoft Copilot, Claude etc.) and humans alike. Normal RAG systems often dump too much or irrelevant context, making it harder, not easier, to work with large repositories.
What if we could feed coding agents with only the precise, relationship-aware context they need - so they truly understand the codebase? That’s what led me to build CodeGraphContext - an open-source project to make AI coding tools truly context-aware using Graph RAG.
What it does Unlike traditional RAG, Graph RAG understands and serves the relationships in your codebase:
1. Builds code graphs & architecture maps for accurate context
2. Keeps documentation & references always in sync
3. Powers smarter AI-assisted navigation, completions, and debugging
Plug & Play with MCP CodeGraphContext runs as an MCP (Model Context Protocol) server that works seamlessly with:VS Code, Gemini CLI, Cursor and other MCP-compatible clients
GitHub Repo → https://github.com/CodeGraphContext/CodeGraphContext
v0.2.1 released
~500 GitHub stars, ~300 forks
25k+ downloads
65+ contributors

value: Show HN: CodeGraphContext- An MCP server that indexes code into knowledge graphs


value: zmam

value: Show HN: CalcVerse – 500 calculators and tools, 100% client-side/private

author: zmam


value: PeterLiu-Trayja

value: When I first built this a few years ago, someone else submitted it to HN before I could. I'm sharing it now myself after making some performance improvements, though it's still quite unusable on certain devices (apologies).

value: Show HN: 3D Modelling in CSS

author: PeterLiu-Trayja

title: Show HN: 3D Modelling in CSS


value: kshowkat

value:
Demo: https://streamable.com/fcy9sg
Brood is a macOS desktop app for iterating on visual ideas where the canvas image is the primary state and text is optional. The UI is an RTS-style tool palette: you pick an operation and apply it to regions of the canvas.
Under the hood, Brood routes each step to an image model/tool (Gemini, OpenAI, Flux) and runs a lightweight policy step that looks at the current canvas and chooses the next operation (eg background removal, recast/style shift, object replace) based on what it infers youre trying to do.
This started as an experiment inspired by Karpathys "the tokenizer must go" / image-input-first argument (https://x.com/karpathy/status/1980397031542989305
 ).
Feedback I want:
Does the RTS-style palette speed up iteration or add distraction?
Which 2-3 operations should be next?

value: Show HN: Brood– an image-first design tool for iterating on visual ideas

author: kshowkat


value: Jonovono

value:
Been loving building things in Hypermedia land. Started playing around with LiveView, but really loved the simplicity of Datastar with Go.
Wanted to build just a simple website where it was live and everyone saw the same thing. Had an idea to wrap some of the concepts of Datastar around a nice JSX syntax so you could build live pages in a single tsx file.
Would love to hear what you think! Been back and forth on the particular dev experience, greatly inspired by convex

value: Show HN: Hyperstar – LiveView/Datastar for TypeScript and JSX

author: Jonovono


value: justvugg

value:
I built llm-use, an open-source tool to run AI agent workflows across multiple LLMs with routing and cost optimization.
Repo: https://github.com/llm-use/llm-use
OpenClaw-style agents are powerful but get expensive if every step runs on a single high-end model. llm-use helps by:
 • using a strong model only for planning and final synthesis
 • running most steps on cheaper or local models
 • mixing local and cloud models in the same workflow
Example:
python3 cli.py exec \
  --orchestrator anthropic:claude-4-5-sonnet \
  --worker ollama:llama3.1:8b \
  --task "Monitor sources and produce a daily summary"
This setup keeps long-running agents predictable in cost while preserving quality where it matters.
Feedback welcome.

value: Show HN: LLM-use – orchestrate LLMs for AI agents like OpenClaw, cut costs

author: justvugg


value: spranab

value: Show HN: SDF Protocol – Pre-compiled semantic JSON for AI agent web consumption

author: spranab


value: roanakb

value:
Hey HN! We're Roanak and Andrew from Trainy (YC S23). We build GPU infrastructure for ML teams (scheduling multi-node training jobs on Kubernetes). When Neptune announced they're shutting down, our customers didn't have a clear path forward. The alternatives exist but none of them matched the UI experience Neptune had, especially at scale. So we decided to build Pluto.
Pluto is an open-source experiment tracker based on our fork of MLOp. The main idea is that you can add one import alongside your existing Neptune code and it logs to both platforms simultaneously. You validate that everything matches on real training runs, then when you're ready, set an env var and all Neptune API calls redirect to Pluto. We also built a Neptune exporter for historical runs.
We're focusing heavily on having a UI that stays responsive at scale, since ML teams can have thousands of runs per project and the tracker is open all day. If you find anything slow or buggy in the playground, we'd love to hear about it.
Beyond the compatibility layer, we're working on: tensor logging with on-the-fly visualization (log raw tensors instead of pre-rendered plots), code diffing between runs, and Linear/Jira integration. We just shipped Pluto MCP in alpha, which lets you query experiment data with an LLM.
Live playground (no signup): https://demo.pluto.trainy.ai/o/dev-org/projects/my-ml-projec...
Quickstart: https://docs.trainy.ai/pluto/quickstart
Listed on Neptune's official transition hub: https://docs.neptune.ai/transition_hub/migration/to_pluto
Let us know what you think! We'd especially love feedback from anyone managing experiment tracking across a team.

value: Show HN: Pluto – open-source Experiment Tracker for Neptune users

author: roanakb


value:
EU AI Act enforcement starts Feb 2026. High-risk AI systems face up to €35M fines if non-compliant.
---
Built a tool that checks AI systems against EU requirements in 2 minutes:
---
→ Risk classification (Annex III check)
→ Governance readiness scoring (6 core requirements)
→ Evidence pack generation (audit-ready, 5 files)
→ Plain English action items
---
Technical details:
→ Multi-LLM support (OpenAI, Anthropic, Mistral, xAI)
→ Zero-dependency evidence generation
→ SHA-256 integrity verification
→ Offline-capable after setup
---
100% free. Open source. FTBL license.
---
Happy to answer questions about the EU AI Act or how the tool works.
---
GitHub: https://github.com/jongartmann/eu-ai-act-layer-lite

value: Show HN: EU AI Act Layer – Free Compliance Checker


value: johndaskovsky

value: Show HN: Long-running unsupervised agent framework

author: johndaskovsky


value: anticlickwise

value:
In many planning meetings, everything sounds important. So everything stays.
Weeks later, progress slows not because people aren’t working hard, but because attention is split across too many “priorities.” I kept seeing the same pattern: teams avoid prioritization not out of laziness but because it forces uncomfortable trade offs.
So I built a small tool called What Comes First. It removes scoring frameworks and debate and forces a single constraint: if only one thing can be first, what actually comes first?
This started as an internal exercise. I built it solo and used Notion heavily to stay organized and recall decisions while iterating.
Would love feedback from people who’ve dealt with priority inflation in real teams.
Link: https://www.cognu.app/what-comes-first

value: Show HN: A forced ranking exercise to stop priority inflation

author: anticlickwise


value: danscan

value:
Hey HN,
I made a Github incident tracker in the style of Github's contribution graph.
We're all feeling Github's increasing issues lately, so I quickly threw this together today. It includes incidents since Jan 2025, trends, and current status.
Hosted on Fly, made with Astro, bun, bun:sqlite.

value: Show HN: GithubDownfall – Track GitHub incidents and downtime

author: danscan


value: flashdoc

value: Show HN: Distill – AI summaries and Worth It scores for YouTube videos

author: flashdoc


value:
Hi HN, we built PaperPod: agent-native sandboxes for code execution, live URLs, browser automation, LLM inference, persistent memory, with 50+ built-in tools (ffmpeg, sqlite, etc.) - all via our CLI tool or HTTP endpoints.
The problem: Existing infra tools require SDK setup, API keys, or clicking through UIs, things agents can't do well.
What we built: On-demand sandboxes accessible via our CLI or HTTP endpoints. Try it right now with any coding agent:
npm install -g @paperpod/cli
ppod login your@email.com
ppod help
What's included:
- Code execution (Python, JS, shell)
- Live preview URLs
- Persistent memory (10MB, survives restarts)
- LLM Inference
- Browser automation (screenshots, PDFs, scraping via Playwright)
- 50+ tools (ffmpeg, sqlite, git, pandoc, imagemagick)
$5 free credits on signup (~14 hours), no credit card required. Built on Cloudflare Containers.
Quick Demo with OpenClaw: https://youtube.com/shorts/gTbyz26mPxk?feature=share
What would make this more useful for your agent workflows?

value: Show HN: PaperPod – Fast, no-setup sandboxes for AI agents


value: oj-hn-dot-com

value:
Hi all,
I've been part of the Hacker News community since 2009 (under a different profile, latchkey), and over the years I've accumulated many ideas for improving the experience. I've used HNES, Refined Hacker News, and other extensions, and saved countless ideas along the way. Many promising projects were eventually abandoned. That may happen here too, but this is something I've wanted to explore personally for a long time. With AI making experimentation easier, now feels like the right time to do it.
The goal isn't to redesign Hacker News. Its minimal UX works, and no one wants to relearn an interface that already does the job. Instead, this project focuses on small, thoughtful improvements—adding features and polish that make HN more pleasant to use without changing its core.
I'm also interested in exploring social features. HN is already a massive social network, but interactions feel fragmented. There's room for tools that make engagement richer, not through obvious features like live chat, but through more creative, viral ideas I plan to experiment with.
Take a look, feedback welcome!

value: Show HN: Orange Juice Hacker News browser extension

author: oj-hn-dot-com


value: holaduder

value: Built this for myself. I never listen back to voice memos but I keep recording them. DayTape transcribes and finds patterns across entries. iOS, free for 20 entries.

value: Show HN: DayTape – record thoughts, get transcripts, takeaways, and patterns

author: holaduder


value: Show HN: The Recovery Kit Ultra

title: Show HN: The Recovery Kit Ultra


value: nicbarth

value: My weekend project was trying to recreate old Twitter. I'd appreciate any feedback or advice you all have. Thanks HN!

value: Show HN: Old Twitter

author: nicbarth

title: Show HN: Old Twitter


value: Show HN: Claude Cowork for Startup Market Analysis


value: Mrakermo

value:
I killed my Calendly link after someone I barely knew booked an intro call  30 minutes before my biggest sales meeting of the quarter. Then another person wedged themselves between two important calls, forcing me to reschedule everything.
The problem: Calendly treats all meetings as equal. It doesn't know that some people matter more, or that some time blocks are sacred.
So I built the opposite. When someone requests a meeting:
1. It searches your email history with that person
2. Understands the context (hot lead vs cold outreach vs investor vs "just curious")
3. Learns your actual schedule preferences (not just "availability")
4. Suggests times that make sense for THIS specific meeting's priority level
Example: A prospect who's been emailing about a deal gets offered your best slots.
Someone wanting to "pick your brain" gets next Tuesday at 3pm and nothing else.
It's still early—I'm using it myself and with ~10 beta users. The context analysis is basic (email volume, reply speed, keywords) but it's already prevented 3 calendar disasters this week.
Built with [tech stack]. Would love feedback, especially from anyone else  who's been burned by the "first-come-first-served" scheduling model.
Live at: https://atimeforeveryone.xyz

value: Show HN: I killed my Calendly link after people booking randomly

author: Mrakermo