value: Facingsouth

value: claude mcp add terradev --command terradev-mcp<p>Ask Claude Code to find the cheapest spot A100 from your own directory of APIs for providers (keys kept local), dry-run multi-cloud provisioning, compress and cache datasets for egress optimization, spin up NUMA-aware Kubernetes clusters, and deploy a GPU snapshot to InferX for fast cold starts, all with conversational language, all running locally with your own API keys.

value: Show HN: Provision Stateless GPU Compute with Claude Code's Remote Control

author: Facingsouth


value: radolang

value: Show HN: Clerk – Simple invoicing for freelancers built with AI agents in 7 days

author: radolang


value: flamestro

value:
I built Deff because AI coding tools sped up writing code, but reviewing their changes became the new bottleneck.
Most of my time was going into checking noisy diffs, understanding intent, and making sure nothing subtle broke.
Deff is focused on one thing: helping you review AI-generated code changes faster and with more confidence.
It helps surface what changed and is allowing me to use it with some vim motions so I can easily jump from nvim to opencode to deff.
Would love feedback from people using AI coding assistants heavily — especially on review workflows, false positives, and what still feels slow.

value: Show HN: Deff – Review AI-generated code changes

author: flamestro


value: FreeGuessr

value:
Hi HN,
I built TuneJourney.com, a web app that lets you explore ~70k radio stations worldwide via a 3D globe. While sites like Radio Garden are great for discovery, I wanted to build something that functioned more like a modern media player with automation—specifically, the ability to automatically skip a station when it switches from music to talking or ads.
The Unique Part: In-Browser ML
The core feature is an "AI Skip Talk." Instead of processing audio on a server, it uses the Web Audio API to capture the stream locally and runs a lightweight classification model directly in your browser. It estimates the "music vs. speech" probability in near real-time.
If you have the filter enabled, it will automatically trigger a "next" command to hop to another station in your playlist or a random location on the globe the moment a DJ, news segment, or ad starts.
Privacy: No audio data ever leaves your machine; inference is entirely local.
The Tech Stack/Features:
- WebGL + Point Clustering: To render 70,000 stations across 11,000 locations smoothly.
- In-browser Inference: Uses a small model plus stream-level heuristics to handle edge cases.
- Media Key Integration: Full support for physical keyboard and system-level Next/Prev buttons.
- Persistence: Sign-in is available to sync playlists and favorites across devices, but the core explorer works without an account.
- Online activity: You can see in real time other people on the site, where they are on the globe, what they listened to, and what stations they liked.
- Simple games to kill the time as you are listening to stations, like Solitaire, Minesweeper, etc.
The Trade-offs & Challenges:
Running a WebGL globe and real-time audio analysis simultaneously is heavy on the CPU. To handle this, I’ve implemented:
- Automatic performance detection that downgrades visuals on lower-end machines.
- A manual toggle to kill the audio processing if you just want to use the globe as a standard player.
- A talk sensitivity slider for the ML model, so you can tweak it yourself.
What I’d love feedback on:
- Performance: How does your CPU/fan react? Is it manageable? I’m looking for ways to further optimize the client-side ML or perhaps it is okay to bring even heavier models with more accuracy.
- Classification Accuracy: How useful is it? Does it detect talking in most of the cases, or is it sometimes useless? On MacBook it works ok-ish. Ads with music are difficult but when music changes to pure talk, the site does its work and hops to another one.
Let me know what you think! I am interested if this project is worth further investment, building a mobile app, etc.

value: Show HN: Tunejourney.com – A 3D radio globe with in-browser ML to auto-skip talk

author: FreeGuessr


value: shineDaPoker

value:
Hey HN,
I built Verity after debugging a production issue where our job platform was sending duplicate emails to tens of thousands of hotel guests.
We were running automated checkout for a chain of hotels across Germany, Spain, and New York. The process had multiple steps: validate reservations, generate folios, check guests out, send receipt emails.
The job would run for 25+ minutes processing thousands of reservations. Sometimes it would time out at 30 minutes. The platform would see the job didn't complete and restart it from the beginning.
The problem: some operations were idempotent through the provider (like creating a folio with the same ID), but others weren't (like sending emails). Guests would get duplicate receipt emails. We'd generate the same reports twice.
It took a week of adding logs to figure out what was happening. The restart was invisible to our code — it just looked like the job was running twice.
I built Verity to solve this: wrap each critical step or side effect so it's safe to restart anywhere:

    // Check out guest
    await verity.protect(`checkout-${reservationId}`, {
      observe: () => hotel.getReservation(reservationId),
      act: () => hotel.checkout(reservationId)
    });

    // Send receipt (not idempotent in the email service)
    await verity.protect(`receipt-${reservationId}`, {
      observe: () => checkIfEmailSent(reservationId),
      act: () => sendReceiptEmail(guest.email, folio)
    });

If the job restarts after sending the email but before finishing, the retry checks first (observe) and skips re-sending.
It uses fencing tokens to prevent zombie workers from committing stale results if they wake up after being timed out. Full audit trail of what ran, what was skipped, and why.
The same pattern applies to any system that retries without human oversight — background jobs, workflow engines like Temporal, or AI agents that make autonomous decisions. If your code crashes after calling an external API, the retry needs to know what already succeeded.
Works with Temporal, Trigger.dev, plain job queues, or standalone.
Still early. Looking for people who've hit similar issues to try it and tell me what's wrong. Free for design partners.
Live: https://useverity.io
Docs: https://useverity.io/docs
Install: npm install @verityinc/sdk or pip install verityinc-sdk
Happy to answer questions about the design or share more war stories from that debugging week.

value: Show HN: Verity – I got tired of debugging duplicate emails after job restarts

author: shineDaPoker


value:
Got banned from HN a few days ago for LLM posting. i honestly deserved it. 100+ comments in a few days, that's just abusive.
I have RSI so I use voice and LLM to type. Dictate my thoughts, model shapes the sentences. I got lazy about where the line was and automated too much.
After getting unbanned I went through all the comments dang has flagged for LLM posting over the years(https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que...) and looked for patterns. Some are obvious, some surprised me:
- curly/typographic quotes (“ ” instead of " ") or even ’ vs ' (that’s is LLM, that's is human)
- humans typing in a browser text box produce straight ASCII. finding curly quotes in a plain HN comment means the text was generated elsewhere and pasted in
- exactly 3 paragraphs of 1-2 sentences each - extremely common LLM output shape
- examples always come in threes - "for example, X, Y, and Z"
- → arrows and — em dashes (sometimes replaced with - en dashes to evade detection)
- overly sycophantic openers - "great point", "this is really interesting" before saying anything
- fake personal framing - "in practice I've found..." immediately followed by a generic claim
Built a detector around these + some heavier signals (TF-IDF cosine similarity across a user's comment history, optional
Anthropic/OpenAI LLM pass). You can paste any HN comment URL/ID or just raw text and see what fires
I ran my own banned comments through it. They score 70-85. Sounds about right.
https://hn-bot-detector.vercel.app/
gh: https://github.com/umairnadeem/hn-bot-detector
I wrote this post myself btw

value: Show HN: I built an LLM comment detector for HN (I got banned)


value: steeferino

value: Show HN: BrainDump – A daily writing prompt site

author: steeferino


value: juanjosegongi

value:
I built PixShot — a screenshot and OG image API. You can try it on the homepage without signing up, just type any URL.
I needed screenshots for a side project and balked at the pricing — Urlbox starts at $29/mo for 5K, ScreenshotOne at $79/mo for 10K. So I built my own on a single VPS. Free tier is 500/mo, paid starts at $19/mo.
Stack: Fastify + Playwright + Sharp + BullMQ + Redis, deployed on OVH with Dokploy. No serverless, no cold starts.
I'm based in Colombia where Stripe doesn't work for merchants, so I used Creem.io as a Merchant of Record — not something I expected to spend time on.
Happy to answer questions about the architecture or pricing.

value: Show HN: PixShot – Screenshot and OG Image API

author: juanjosegongi


value:
I built 8 Model Context Protocol servers for common self-hosted services (Proxmox, n8n, Grafana, AdGuard, Portainer, Ollama, Uptime Kuma, Mattermost).
Each server lets Claude Desktop talk directly to your homelab infrastructure via natural language -- no custom API wrappers needed.
40 tools total. Pure Python, no external dependencies beyond the mcp package.
GitHub: https://github.com/AI-Engineerings-at/homelab-mcp-bundle

value: Show HN: Open-source MCP servers for self-hosted homelab AI


value:
I built a self-hosted observability server that exposes production data as MCP tools. Instead of switching between dashboards and your editor, you connect it to Claude Code, Cursor, or any MCP client and query your logs, database, and server metrics through natural language.
What it covers:
- Log ingestion with full-text search (SQLite FTS5), filters by service, level, trace ID, exception class, metadata
- Read-only Postgres introspection — query stats from pg_stat_statements, index analysis, lock chains, bloat estimates, replication lag. All queries validated SELECT-only via SQL AST parsing (pg_query)
- Sentry-style error grouping by fingerprint with user impact analysis
- User analytics — session journeys, conversion funnels, path analysis, top endpoints
- VM monitoring — CPU, memory, disk, network via gopsutil
- Rule-based threshold watches with auto-resolve
The AI assistant can also take actions: resolve errors, create watches, set up health checks, kill slow queries, and save persistent notes across sessions.
Tools return suggested_tools with pre-filled arguments, so the assistant chains through investigations without prompt engineering.
Stack: Go, SQLite (WAL + FTS5), Chi, HTMX. Single binary, no external dependencies. Runs on a $4 VPS.
Client libraries: Ruby gem for Rails (auto-captures SQL, N+1s, view renders, ActiveJob, PII redaction) and a 3.1KB browser JS client for frontend error tracking.
https://github.com/adham90/opentrace

value: Show HN: OpenTrace – Self-hosted observability server with 75 MCP tools


value:
I've been building a Rails engine for managing LLM-powered agents in production. The main problem it solves: you define agents with a Ruby DSL, and everything else — cost tracking, retries, fallbacks, circuit breakers, caching, multi-tenancy, and observability — is handled by a middleware pipeline.
It ships with a mountable dashboard that shows execution history, spending charts (cost/tokens over time), per-agent stats, model breakdowns, and multi-tenant budget management with hard/soft enforcement.
Works with OpenAI, Anthropic, Google, ElevenLabs via RubyLLM. Supports text agents, embedders, TTS, transcription, image generation, message routing, and agent-as-tool composition.
v3.7, MIT licensed, ~4000 specs. Would appreciate feedback on the DSL design and middleware architecture

value: Show HN: RubyLLM:Agents – A Rails engine for building and monitoring LLM agents


value: sergegriimm

value:
I spent like 2 months building a tool to solve a problem we had: How do you enforce architectural decisions automatically?
Problem: We're a team of ~20 engineers. Started with clean architecture. Now it's... let's just say "creative layering"
Real issues:
- 40% of PRs were rejected just for architecture violations
- Code review became the bottleneck (architectural review ≠ logic review)
- Junior devs didn't understand the implicit rules
- No way to catch violations automatically
Solution: architect-linter
It's like ESLint, but for your entire system design. Define rules in architect.json, architect validates imports across your codebase.
Key features:
- Multi-language: TypeScript, JavaScript, Python, PHP (all via Tree-sitter)
- Multi-architecture patterns: Hexagonal, Clean, MVC
- Fast: Written in Rust, parallel processing
- Free & open source (MIT license)
- Works in CI/CD, pre-commit hooks, watch mode
Example rule:
```json
{
  "forbidden_imports": [
    {
      "from": "src/components/*",
      "to": "src/services/*",
      "reason": "UI layer shouldn't call services directly"
    }
  ]
}

value: Show HN: Architect-Linter – Enforce architecture rules

author: sergegriimm


value: ascarola

value: A Unix-inspired shell and RAM filesystem for the Commodore 64 (6502 assembly)

value: Show HN: Unix for the Commodore 64? Open Source

author: ascarola


value: Scan any site and generate WebMCP tool definitions for AI agents. Open source CLI. Deploy with one script tag, test in an agent playground, and A/B test your definitions to find what agents prefer. All at agents.keak.com.

value: Show HN: WebMCP Core – AI agent tool definitions from any site


value: eronmmer

value: Show HN: Bloomfilter – A service for AI agents to register and manage domains

author: eronmmer


value: we built an agent that does basically everything that an advisor from Fidelity would do for you. It's a beta release so there is still much to do but I'd love to get feedback

value: Show HN: Taji – Portfolio advisor that's better than Fidelity's


value: zyoralabs

value:
I've been building ZSE (Z Server Engine) for the past few weeks — an open-source LLM inference engine focused on two things nobody has fully solved together: memory efficiency and fast cold starts.
The problem I was trying to solve:
Running a 32B model normally requires ~64 GB VRAM. Most developers don't have that. And even when quantization helps with memory, cold starts with bitsandbytes NF4 take 2+ minutes on first load and 45–120 seconds on warm restarts — which kills serverless and autoscaling use cases.
What ZSE does differently:
Fits 32B in 19.3 GB VRAM (70% reduction vs FP16) — runs on a single A100-40GB
Fits 7B in 5.2 GB VRAM (63% reduction) — runs on consumer GPUs
Native .zse pre-quantized format with memory-mapped weights: 3.9s cold start for 7B, 21.4s for 32B — vs 45s and 120s with bitsandbytes, ~30s for vLLM
All benchmarks verified on Modal A100-80GB (Feb 2026)
It ships with:
OpenAI-compatible API server (drop-in replacement)
Interactive CLI (zse serve, zse chat, zse convert, zse hardware)
Web dashboard with real-time GPU monitoring
Continuous batching (3.45× throughput)
GGUF support via llama.cpp
CPU fallback — works without a GPU
Rate limiting, audit logging, API key auth
Install:
-----
pip install zllm-zse
zse serve Qwen/Qwen2.5-7B-Instruct
For fast cold starts (one-time conversion):
-----
zse convert Qwen/Qwen2.5-Coder-7B-Instruct -o qwen-7b.zse
zse serve qwen-7b.zse  # 3.9s every time
The cold start improvement comes from the .zse format storing pre-quantized weights as memory-mapped safetensors — no quantization step at load time, no weight conversion, just mmap + GPU transfer. On NVMe SSDs this gets under 4 seconds for 7B. On spinning HDDs it'll be slower.
All code is real — no mock implementations. Built at Zyora Labs. Apache 2.0.
Happy to answer questions about the quantization approach, the .zse format design, or the memory efficiency techniques.

value: Show HN: ZSE – Open-source LLM inference engine with 3.9s cold starts

author: zyoralabs


value: adamschwartz

value:
This is a little weather app I’ve been refining on and off for a long time. It serves two purposes for me:
1) It displays the temperature in the favicon. This helps me keep track of the temp throughout the day since I keep this page always open as the left-most pinned tab in my browser.
2) It shows only the information I’m typically interested in: the conditions right now and projected temperature changes over the next few hours.
The data comes from https://api.weather.gov, so sadly it is US-only for now.
You can get a forecast from most US cities or you can enter a specific latitude and longitude.
No AI was used in the making of this site. (Not a flex, just sadly a relevant thing these days.)

value: Show HN: Weather app with temp (23°) in favicon

author: adamschwartz


value: justinko

value:
I've been a developer for 20+ years and reviewer selection has been a recurring problem at every company I've worked at. Either you're a CODEOWNER getting spammed on every PR, or you're in Slack trying to find someone who actually knows the code you changed. CODEOWNERS is too coarse — it maps paths to people, but doesn't account for who's available, who reviewed this author before, or who actually touched these files recently.
I built PullMaster to fix this. It's a GitHub App that analyzes your repo's actual history and recommends the best reviewer for each PR. It adapts to the risk level of each change, so critical PRs surface experienced reviewers while routine ones get distributed across the team.
Install the GitHub App and comment `@pullmaster-ai suggest` on a PR to get a recommendation with an explanation, or `@pullmaster-ai assign` to also request the review automatically. No configuration needed — it learns from your repo as soon as it's installed.
It's free. I'd use it at my day job but being in a heavily regulated industry without SOC 2 makes that a non-starter, so I'm looking for early users and feedback. Happy to answer questions about how it works.
https://www.pullmaster.ai

value: Show HN: PullMaster – Recommends code reviewers from your repo history

author: justinko


value: usplusAI

value: Show HN: Usplus.ai – OpenClaw for Enterprise. Autonomous Agents to get work done

author: usplusAI


value:
I reset the structure hundreds of times to get here.
Each time I was sure, I tore it down to zero again.
Failure was the only friend that kept giving direction.
What remained after all that:
- Don't Trust, Verify
- Not a single byte changes
- If it cannot be reproduced, it is not evidence
EV424 is just deterministic byte-sameness receipts.
No interpretation. No truth claims. No hosting originals.
Only G1–G5 closed gates → reproducible PASS/FAIL.
Still early. Mostly spec, not much code yet.
But the question that keeps coming back is:
In a world where AI makes everything look convincing fast,
is "reproducible only" still enough?
https://github.com/ev424verify/ev424-hub

value: Show HN: EV424 – Reproducible Integrity Receipts (Don't Trust, Verify)


value: unohee

value:
I built OpenSwarm because I wanted an autonomous “AI dev team” that can actually plug into my real workflow instead of running toy tasks.
OpenSwarm orchestrates multiple Claude Code CLI instances as agents to work on real Linear issues. It:
• pulls issues from Linear and runs a Worker/Reviewer/Test/Documenter pipeline
• uses LanceDB + multilingual-e5 embeddings for long‑term memory and context reuse
• builds a simple code knowledge graph for impact analysis
• exposes everything through a Discord bot (status, dispatch, scheduling, logs)
• can auto‑iterate on existing PRs and monitor long‑running jobs
Right now it’s powering my own solo dev workflow (trading infra, LLM tools, other projects). It’s still early, so there are rough edges and a lot of TODOs around safety, scaling, and better task decomposition.
I’d love feedback on:
• what feels missing for this to be useful to other teams
• failure modes you’d be worried about in autonomous code agents
• ideas for better memory/knowledge graph use in real‑world repos
Repo: https://github.com/Intrect-io/OpenSwarm
Happy to answer questions and hear brutal feedback.

value: Show HN: OpenSwarm – Multi‑Agent Claude CLI Orchestrator for Linear/GitHub

author: unohee


value: Show HN: ImageCFN – Analog, Resolution-Independent Image Representation


value: Show HN: Decision Tree Builder

title: Show HN: Decision Tree Builder


value: Show HN: Relocate.ai – AI reports for families moving abroad


value: yomwolde

value:
I’ve been experimenting with a side project that explores automating image localization.
The pipeline takes an image containing text, detects text regions, removes the text, translates it, then re-renders it in a target language while attempting to preserve layout and visual balance.
The goal is not perfect marketing copy or pixel-perfect DTP replacement. It is more about testing whether “good enough” localized visuals can be generated without manually recreating assets for each language.
Some things I’ve been curious about while building this:
• How different scripts behave (Latin vs CJK vs RTL)
• Where layout preservation breaks down
• Whether this is actually useful or just a novelty demo
• What production constraints would make this impractical
Examples: https://postimg.cc/gallery/1X04QFz
If anyone here works with localization, design systems, or asset pipelines, I’d genuinely love to hear where you think this approach would fail.

value: Show HN: Automatic Image Localization Pipeline

author: yomwolde


value: bobbydotdesign

value:
I'm a product designer & front-end engineer who's been building with AI coding agents for the past year and working on teams launching AI products even longer. I always found the tools to be powerful, but the workflow around them  lacking. I was constantly bouncing between terminals, browsers, file managers, and a rotating cast of IDEs. Nothing ever hit the right balance of simplicity and control.
So, like any completely over-burdened dad and leader, I built my own. Projekt is an agent-agnostic workspace that consolidates everything into one place. Bring your own key, bring your own agent — Claude Code, Codex, Gemini, Opencode, whatever you prefer.
It's still early. The alpha is free and I'm looking for people to help find rough edges and squash bugs. I've built 2 apps using it so far and the experience has been exactly what I was looking for. My roadmap is public and I plan to develop it rapidly.
Download the free alpha at https://getprojekt.com or grab the Founders Tier.
Happy to answer any questions about the architecture, the design decisions, or the agent-agnostic approach.
Thanks!

value: Show HN: Projekt [Free Alpha] – All-in-one workspace for building with agents

author: bobbydotdesign


value: mollynpaan

value:
I got tired of Apple Mail not reliably flagging calendar events. And even when it did work, other events shared on iMessage, Slack, or random webpages still had to be manually copy-pasted into my Calendar. This got frustrating enough that I decided to claude-code a little utility to help me with this. Here's how it works:
You select any text on your Mac — an email, a Slack message, a webpage — right-click, hit "Add to Calendar," and it uses Gemini Flash to parse out the event title, date/time, location, and notes. You get an editable preview before anything gets saved to Apple Calendar.
It's bringing me joy everyday. Hope it helps you too!

value: Show HN: Right-click any text on macOS to add it to your calendar (open-source)

author: mollynpaan


value: juanfiguera

value:
"Buy me a house. Budget $475K. Good school district. Handle it." That's where AI agents are headed. One already bought someone a car last month, negotiating $4,200 off across dealerships via email. Its entire authorization framework was a prompt: "ask me before doing anything consequential." It also sent a confidential email to the wrong person.
APOA is the missing infrastructure: an open standard for formally delegating bounded authority to AI agents. Scoped permissions, audit trails, instant revocation, credential isolation. Builds on OAuth 2.1, JWT, ZCAP-LD.
Working draft, Apache 2.0. Looking for feedback from anyone building agent infrastructure or working on auth standards. Please poke holes at it!

value: Show HN: Agentic Power of Attorney (APOA) – An open standard for AI agent auth

author: juanfiguera


value: rafapra

value: Show HN: Lingua Universale – session types and Lean 4 proofs for AI agents

author: rafapra


value: Show HN: Discord CLI designed for agents to explore/read/send messages


value: sebastiandoyle

value: Show HN: Sidedesk – An AI assistant inbox that looks like Outlook 2003

author: sebastiandoyle


value: anulum

value:
Hey HN,
After watching too many agents confidently lie in production, I built Director-AI.
It sits between your LLM and the user, scoring every generated token with:
• 0.6× DeBERTa-v3 NLI (contradiction detection)
• 0.4× RAG against your own ChromaDB knowledge base
If coherence < threshold → Rust kernel halts the stream before the token is sent.
Key technical bits:
• Works with any OpenAI-compatible endpoint (Ollama, vLLM, llama.cpp, Groq, OpenAI, Claude…)
• StreamingKernel + windowed scoring
• GroundTruthStore.add() for easy fact ingestion
• Dual licensing: AGPL open + commercial (closed-source/SaaS OK)
Honest AggreFact numbers inside (66.2% balanced acc with streaming enabled). Not claiming SOTA on static NLI — the value is in the live gating + custom KB system.
Repo + full examples: https://github.com/anulum/director-ai
Would love feedback on the scoring weights, halt logic, or kernel design. What hallucination problems are you solving today?

value: Show HN: Director-AI – token-level NLI+RAG

author: anulum


value: bikidev

value:
Most AI agents forget everything between sessions. We built DeltaMemory to fix that.
It's a cognitive memory layer that gives agents persistent recall, automatic fact extraction, and temporal reasoning — via a single SDK call.
Key numbers:
- 89% accuracy on LoCoMo long-term conversation benchmark
- 50ms p50 retrieval latency
- 97% cost reduction vs raw token re-processing
Open source SDKs, works with any LLM stack. Currently in early access.
Happy to answer questions about the architecture, benchmark methodology, or how we handle knowledge graphs.

value: Show HN: DeltaMemory – Persistent cognitive memory for production AI agents

author: bikidev


value: resetmerlin

value:
Hello. We built an AI learning service that lets you create a curriculum on any topic you want and study without worrying about hallucinations.
While existing AI learning services have mostly focused on how much text inside a PDF the AI can read and answer from, we focused more on how the AI should explain and guide so that real learning actually continues. That’s why we aimed to make it feel less like a simple Q&A tool and more like studying with a teacher who knows how to teach well.
It’s also simple to use.
1. Enter what you want to learn, choose your level and the number of chapters, and a curriculum is generated.
2. Click the curriculum card you want and start learning right away.
3. Each chapter comes with both a tutorial and a chatbot, and the chatbot continues the conversation while understanding the context of the current chapter.
4. So even when a user gets a quiz question wrong, they don’t have to explain everything again from the beginning; the AI can reflect the situation and help immediately.
Lastly, to briefly explain why we built this service: just because the AI era has arrived doesn’t mean the quality of education has automatically improved.
In fact, we felt that with AI added on top of short, stimulating content consumption like Reels or Shorts, people often lose focus when trying to study.
So we focused on reducing the real problems that get in the way of studying with AI, like hallucinations, unstructured learning flow, and the limits of traditional education methods that still haven’t changed.
Thank you.
Service link: https://runtric.com/

value: Show HN: Runtric – Turn any topic into a chapter-based learning path

author: resetmerlin


value:
I've been using Oh-My-OpenCode (OmO) — a multi-agent orchestration plugin for terminal-based AI coding — and it's great. But being terminal-only kept bugging me:
- Can't kick off work from my phone. I'd want to say "implement this feature" while I'm out, but I'd have to open my laptop.
- No async workflow. I have to stay attached to the terminal until it's done.
- Can't run multiple tasks in parallel. One session, one task, sequentially.
- Sometimes I come back and it's just sitting there waiting for a clarification question.
- The web UI exists but it's slow. Discord and Telegram are right there — polished, fast, on every device.
So I ported OmO's multi-agent patterns to OpenClaw (a chat-platform AI agent framework) and built a plugin that actually integrates with OmO.
Then I hit a second set of problems on the OpenClaw side:
- The agent tries to do everything itself instead of using sub-agents.
- To use OpenCode for coding, I had to explicitly say "open tmux, run opencode, do the work there" every time.
- Opus 4.6 as the main model means weak multimodal. I'd have to manually route screenshots and PDFs to Gemini CLI.
Oh-My-OpenClaw (OmOC) solves both sides.
What it does:
1. Fully async, from any chat platform. Type `/omoc omoc_prometheus` in Discord or Telegram and walk away. Planning → agent dispatch → execution → verification runs autonomously. Works from your phone.
2. 11 specialized agents, auto-orchestrated. Not one model doing everything — a team. Prometheus plans, Atlas orchestrates, Sisyphus-Junior implements, Oracle architects, Momus reviews. Each has a specific mandate and personality. The orchestrator (Atlas) delegates, verifies every result, and never writes code itself.
3. Automatic model routing per task category. Simple search? Sonnet. Complex refactor? Opus. Architecture decision? GPT-5.3 Codex. Visual/UI work? Gemini 3.1 Pro. The right model for the right job, configured in one JSON file.
4. OmO + tmux integration. When coding work comes in, OmOC automatically delegates to OpenCode/OmO running in tmux. No manual "open tmux and run opencode" instructions. Gemini CLI multimodal analysis is also auto-routed through tmux.
5. Todo enforcer tracks every step and warns when work is incomplete.
Architecture:
Planning (Prometheus/Metis/Momus)
  → Orchestration (Atlas)
    → Workers (Sisyphus-Junior/Hephaestus/Oracle/Explore/Librarian)
      → tmux: OpenCode/OmO (actual coding)
      → tmux: Gemini CLI (multimodal analysis)
The plugin layer (TypeScript) enforces all of this at the code level:
- Session-scoped in-memory todo tools — agents must plan before executing
- Comment checker — 11 regex patterns kill AI slop comments on sight
- Keyword detector — auto-routes to the right workflow based on what you type
- Checkpoint system — save/load execution state for crash recovery
Two commands. The setup wizard configures all 11 agent personas with your preferred model providers.
Works without OmO — you get the full multi-agent orchestration on OpenClaw alone. *Works with OmO* — you get OmO's full power (AST-grep, LSP, 55+ hooks) accessible from chat, no terminal needed.
Still early. There's plenty of rough edges. Feedback, issues, and PRs are all very welcome.

value: Show HN: Oh-My-OpenClaw – agent orchestration for coding, from Discord/Telegram


value: codeinput

value: Show HN: Browser extension to improve CODEOWNERS for GitHub

author: codeinput


value: thedaviddias

value:
I have been wondering how much AI is used by open-source projects on Github.
So I created a small project on https://aivshuman.thedaviddias.com/ which parses commits and try to find trace of AI tools. Not 100% accurate, it depends on people commiting using AI.
That's only when you can potentially determine that AI tools were used. It's interesting and triggers some questions about if we should have a better or stricter way to measure AI vs Human produced code.
Feel free to share any thoughts or improvements! The project is open source (https://github.com/thedaviddias/ai-vs-human)

value: Show HN: AI vs. Human, a GitHub Visualization

author: thedaviddias


value: mikeday

value:
We've been working on Prince for over twenty years and consider it the best way of getting HTML + CSS (and now Markdown!) into PDF, so it's bothered me that AI agents struggle with this, even writing Python programs to generate PDF and then getting confused when you ask for edits. So we've made an MCP server to make PDFs easier!
It exposes three tools: markdown_to_pdf, html_to_pdf, and url_to_pdf, so prompts like "Create a beautifully formatted invoice" can be handled appropriately. LLMs are great at generating Markdown and HTML and Prince is great at typesetting it to high-quality PDF, so this workflow should assist with documents that require careful formatting, multiple revisions, or PDF accessibility features.
We're still figuring out the best way to package this so it can be used ergonomically. Our first attempt simply returned the PDF file to the agent directly, but the LLM would often struggle to decode it, so now it caches the PDF on the server and returns the URL for you to download it, which keeps the response small and the agent happy. (There's a download button widget to make it look nicer in ChatGPT).
I'm curious if anyone has been making PDFs from AI agents and what they think of this approach! Of course you could also call Prince through a local/stdio MCP or run it directly from the command-line, or use the DocRaptor online service, but it's nice to have an example to play with that only requires pasting in the endpoint without installing anything or even creating an account.
Website: https://prince.cloud
Prince: https://www.princexml.com
DocRaptor: https://docraptor.com/

value: Show HN: Prince Cloud – Create PDFs with AI Agents

author: mikeday


value: kaantahti

value:
I built a tiny library that verifies LLM outputs against constraints and retries on failure.
The core insight: LLMs don't reliably follow instructions, but you can catch failures cheaply and retry with targeted feedback. This is essentially a lightweight "process reward model" that requires zero training.
How it works:
1. Your LLM generates output
2. ai-assert checks it against constraints (length, word count, sentence count, regex, custom predicates)
3. Each constraint returns a score in [0,1] -- composite is multiplicative (zero in any = zero overall)
4. If score < threshold, retry with feedback ("Constraint X failed because Y -- regenerate")
5. Return the best-scoring attempt
On IFEval (25 instruction-following constraint types): 69.3% -> 76.2% accuracy.
278 lines. Zero dependencies. Works with any callable that takes a string and returns a string.
pip install ai-assert
https://github.com/kaantahti/ai-assert

value: Show HN: AI-assert – Constraint verification for LLM outputs (278 lines, Python)

author: kaantahti


value: sbharadwaj

value: Show HN: Marcus –AI math tutor that guides you to answers instead of giving them

author: sbharadwaj


value:
NovelStar is a retro-styled, Windows 95-inspired desktop novel writing application built as a single portable HTML file. It brings professional manuscript formatting, scene/chapter organisation, word count tracking, and full-manuscript PDF export into a clean, distraction-friendly writing environment — no subscription, no cloud, no account required.
It runs entirely in your browser as a standalone .html file
Written by: pixeldude84
Code generated by: Claude (Anthropic AI)
License: GNU General Public License v3.0 (GPL-3.0)

value: Show HN: NovelStar – a functional novel writing suite in a single HTML file


value: faalbane

value: AI-enabled autoexpanding Google Places search / email enrichment

value: Show HN: Easyemailfinder.com (5 Free Credits)

author: faalbane


value: Squidy is an open source Python CLI that interviews you about your project and generates the complete governance structure automatically.

value: Show HN: Squidy – How I stopped losing AI agent context mid-project


value:
I've developed a simple AI-powered audio translator that converts your audio and video files into text or multiple languages within minutes. Fast, accurate, and secure.
Simply drag and drop your audio file or import it from your device, select the target translation language, and let our AI convert your audio into precise text. Once converted, you can download the translated transcript in multiple formats. Everything runs entirely within your browser.
I'm primarily seeking feedback on output quality, user experience, and any technical improvements worth exploring.

value: Show HN: Free online audio translator that translates voice instantly


value:
Hey HN —
I’ve been building real-time audio-reactive graphics software for the past 7 years. It started as a side project while working full-time as a software engineer, and slowly evolved into VISUALZ — a GPU-accelerated VJ engine focused on low-latency audio analysis, and reactive visuals.
Two years ago I decided to take it further and prototype dedicated hardware: the CVJ-1. It’s essentially a compact, touch-screen VJ deck designed mainly for live performance.
We're hoping to get some pre-orders. To get the next phase of manufacturing moving forward.

value: Show HN: CVJ-1 VJ Deck / VISUALZ audio-reactive VJ software


value: vdw

value:
Hi HN,
I’ve been experimenting with WebRTC and Rails 8 to see if it's possible to build a messaging utility that is truly "stateless". I wanted to create something for those moments when you need to move a snippet of text or a file between devices without leaving a trace on a server, a database, or a third-party cloud.
The AI Collaboration: I also want to mention that this project has been a deep dive into collaborating with AI. I used AI to brainstorm the "Zero-Trace" architecture, help me harden the infrastructure after a security audit.
How it works:

    Zero-Trace Architecture: No accounts, no cookies (beyond basic security), and absolutely no server-side logging.

    Client-Side Encryption: Encryption keys stay in the URL fragment (#). Since fragments are never sent to the server, the signaling layer is cryptographically blind to your data.

    P2P Signaling: We use ActionCable for the initial handshake. Once the WebRTC DataChannel is established, the conversation and file transfers happen directly between browsers.

    Zero Third-Party Dependencies: No external fonts, scripts, or trackers. Everything is served from the origin to prevent IP leakage to third-party providers.

The Beta Experiment: I'm currently testing the stability of the P2P signaling. I’ve enabled file transfers (up to 24MB) for everyone during this phase. I’m curious to see how the connection logic handles different network environments.
The Tech Stack:

    Framework: Rails 8
    Deployment: Kamal 2 on a single VPS

I’d love to get your thoughts on the UX and any edge cases you find with the WebRTC handshake!

value: Show HN: Nullroom.io – Experimental, stateless P2P messaging and file sharing

author: vdw


value: dpweb

value: Show HN: Check Your Latency

author: dpweb

title: Show HN: Check Your Latency


value:
I built a system that gives LLMs persistent memory from conversations — not through RAG or databases, but by editing the model's actual weights. The knowledge lives in the parameters. The context window is empty.
During wake, facts from conversation are injected directly into MLP weights via MEMIT (a single forward pass, instant recall). During sleep, the system audits which memories degraded, refreshes them with null-space constraints (guaranteeing orthogonality to working memories), then progressively transfers knowledge into LoRA — like biological memory consolidation from hippocampus to neocortex.
The key problem was a hard capacity ceiling: the 8B model sustains 0.92 recall up to 13 facts, then crashes to 0.57 at fact 14 — a sharp phase transition, not gradual decay. And LoRA consolidation was blocked by what I call the "alignment tax": RLHF training fights back against injected knowledge (37% recall loss on 8B from a single LoRA pass).
The fix: per-fact graduated consolidation. Each fact independently tracks its own stage and advances only when LoRA proves it absorbed that specific fact. A dissolution schedule (1.0 → 0.5 → 0.1 → 0.0) gradually removes the MEMIT edit as LoRA takes over. And cumulative fusing — training each cycle on the already-fused model — reduces the alignment tax from catastrophic to negligible (starting loss drops 2.91 → 0.62 by cycle 2).
Results on Llama 3.1 8B (4-bit, 2×H100):
- 100% advancement rate at 5/10/15/20 facts
- 1.00 chat recall at all scales
- MEMIT edits dissolve on schedule, making the buffer renewable
- Effective lifetime capacity: unbounded
There's also a biological curiosity: individual facts consolidate at different rates. One synthetic fact ("Aria lives in Portland") is consistently the hardest across very run — some memories are just harder to absorb, same as in biological systems.
6 papers documenting the full journey from initial LoRA prototype to this result: https://doi.org/10.5281/zenodo.18779159
Built with: Python, PyTorch, PEFT, BitsAndBytes, Llama 3.1. Runs on MacBook Air (3B) or H100 (8B/70B).

value: Show HN: Sleeping LLM – A language model that remembers by sleeping


value: JohannaWeb

value:
Hi HN — I've been working on Falcon, a developer collaboration platform built around portable identity instead of server ownership.
The core idea: communities shouldn't disappear when a platform, server, or admin does. Your identity and relationships should persist.
This latest iteration moves Falcon into a service-oriented architecture and introduces a trust-gated access model tied to AT Protocol identities.
What's new:
Identity-first access: entry to communities based on verified identity + trust signals, not invite links
Trust service: prototype for reputation/relationship-based gating
Gateway: auth + routing boundary for identity-aware services
Real-time infra: JetStream-backed messaging layer in progress
Mono-repo with bounded services: gateway, trust, messaging (SIV), client, protocol lexicons
The goal isn't "decentralization for its own sake." It's to test whether developer communities would coordinate differently if identity and membership weren't locked to a single platform like Discord or Slack.
Still early:
prototype stage
infra evolving quickly
no production deployment yet
I'm a solo founder with 10 years of backend experience, building this because my community needs it.
I'm especially looking for feedback from OSS maintainers, infra/protocol engineers, and teams running private dev communities.
Main question: Would identity-portable, trust-gated communities actually change how dev groups collaborate — or is platform gravity still too strong?
repo: https://github.com/JohannaWeb/ProjectFalcon

value: Show HN: Trust-gated developer communities with portable identity (AT Protocol)

author: JohannaWeb


value: jbrake

value:
I built a mail merge tool that connects to Airtable views, Google Sheets, or CSV files and sends personalized emails through your own Gmail or SMTP account.
The problem I was solving: I had contact lists in Airtable and needed to send personalized emails — but didn’t want to stitch together something with Zapier + SendGrid and I didn’t want my data flowing through a third-party email service. I wanted something that reads from the spreadsheet, lets me write a Handlebars template with variables and conditionals, preview every email, and send directly.
Tech: Electron + React + Express. Desktop mode encrypts credentials locally with safeStorage, forks the Express server as a child process. Airtable integration parses view URLs and respects view filters/column visibility. Fuzzy matching (Fuse.js) auto-maps template variables to column names.
One-time purchase, 14-day free trial.

value: Show HN: SendView – Mail merge from Airtable/GSheets, sends through your email

author: jbrake


value: youio

value:
One-shot prompt: "$tlaps-workbench Model simplified Raft leader election (terms, votes). Prove leader uniqueness per term and monotonic term growth."
TLAPS Proof: https://github.com/younes-io/tlaplus-workbench-examples/blob...

value: Show HN: I Made an AI Skill to Help Write Tlaps Proofs

author: youio


value:
Context Harness is a single Rust binary that gives AI tools like Cursor and Claude project-specific memory. It ingests docs, code, Jira tickets, Slack threads, and anything else into a local SQLite database, indexes them with FTS5 and optional vector embeddings, and exposes hybrid search via CLI and an MCP-compatible HTTP server.
I built this because I kept hitting the same problem: AI tools are powerful but have no memory of my complex multi-repo project. They can't search our internal docs, past incidents, or architecture decisions. Cloud RAG services exist, but they're complex, expensive, and your data leaves your machine. I wanted something I could point at my sources and just run `ctx sync all`.
Quick start:

    # Install (pre-built binaries available for macOS/Linux/Windows)
    cargo install --git https://github.com/parallax-labs/context-harness.git

    # Create config and initialize
    ctx init

    # Sync your data sources (filesystem, Git, S3, or Lua scripts)
    ctx sync all

    # Search from CLI
    ctx search "how does the auth service validate tokens"

    # Or start the MCP server for Cursor/Claude Desktop
    ctx serve mcp

What it does differently from other RAG tools:
- *Truly local*: SQLite + single binary. No Docker, no Postgres, no cloud. Local embeddings (bundled or pure-Rust) so semantic and hybrid search work with zero API keys. Back up your entire knowledge base with `cp ctx.sqlite ctx.sqlite.bak`.
- *Hybrid search*: FTS5 keyword scoring + cosine vector similarity with configurable blending. Works without embeddings too (keyword-only mode); with local embeddings you get full hybrid search offline.
- *Lua extensibility*: Write custom connectors, tools, and agents in Lua without recompiling anything. The Lua VM has HTTP, JSON, crypto, and filesystem APIs built in.
- *Extension registry*: `ctx registry init` installs a Git-backed community registry with 10 connectors (Jira, Confluence, Slack, Notion, RSS, Stack Overflow, Linear, etc.), 4 MCP tools, and 2 agent personas.
- *MCP protocol*: Cursor, Claude Desktop, Continue.dev, and any MCP-compatible client can connect and search your knowledge base directly.
Embeddings: you can run *fully offline* — the default build uses local embeddings (fastembed with bundled ONNX on most platforms, or a pure-Rust tract path on Linux musl and Intel Mac). No API key required. Optional: Ollama (local LLM stack) or OpenAI if you prefer. Keyword-only mode needs zero deps. There's no built-in auth layer; it's designed for local or trusted network use.
Stack: Rust, SQLite (WAL mode), FTS5, mlua (Lua 5.4), axum, MCP Streamable HTTP. MIT licensed.
GitHub: https://github.com/parallax-labs/context-harness
Docs: https://parallax-labs.github.io/context-harness/
Community Registry: https://github.com/parallax-labs/ctx-registry
If you find it useful, a star on GitHub is always appreciated.
Would love feedback on the search quality tuning (hybrid alpha, candidate counts) and the Lua extension model.

value: Show HN: Context Harness – Local first context engine for AI tools


value: clroot

value: Show HN: Snaplake – Query past database states without restoring backups

author: clroot


value:
I built a web scraping tool where you describe the data you want in plain English instead of writing CSS selectors or XPath.
The problem: Traditional scrapers break when websites change their HTML structure. You spend more time maintaining selectors than actually using the data.
How it works: Send a URL + an AI prompt like "extract all product names and prices as JSON" and the AI reads the page like a human, returning structured data.
Tech stack: FastAPI backend, Gemini 2.5 Flash for extraction, Playwright for rendering, deployed on Google Cloud Run.
Free tier: 500 credits, no credit card required. Would love feedback from HN on the approach and pricing.

value: Show HN: LucidExtractor – Extract web data in plain English, no selectors


value: shreyaspapi

value: Show HN: Onera – Private LLM Inference Inside AMD SEV-SNP Enclaves

author: shreyaspapi


value: Gregoryy

value:
Created this CLI client for Bing Webmaster to let my agents automate SEO reporting and improvements on Bing.
Works via API key auth (from ENV of CLI argument).
Repo includes a skill that can be installed in your OpenClaw agent.
I also have a CLI for Google Search Console: https://github.com/NmadeleiDev/google-search-console-cli
- from the developer of https://openclaw-setup.me

value: Show HN: Bing Webmaster CLI for Agents and LLMs

author: Gregoryy


value: guico

value:
Hey guys!
While building another SaaS we got fed up with recording and, re-recording demos for help-center so decided to try and automate it using Playwright. Turns out it's not that easy, but we got it to a point that's usable, and quite useful for us already.
Feel free to try and send feedback. Every new account gets some free credits so you can see what it can do.
Thanks!
PS: Because this is heavy on infra we have a waitlist thing but I'm monitoring and will let you in within minutes/hours, just need to space people out a bit. Thanks
PPS: Here's an example video made with Rundown https://www.rundown.video/011fb9da-72f7-41d1-bdce-f187f398e0...

value: Show HN: Programmatic (and self-updating) SaaS demo videos

author: guico


value: danielyefet

value:
I'm an engineering manager and built this to solve a problem I kept running into: no good way to track team capability without either a sprawling spreadsheet or an expensive HR system.
Skillscape lets you map your team against a structured L1–L4 skill framework, spot coverage gaps and bus factor risks, and define custom role frameworks. Free for small teams.
Would love feedback from other managers or engineers who've dealt with this — does the problem resonate? Is this the right solution?

value: Show HN: Skillscape – Engineering skills matrix without the spreadsheet

author: danielyefet


value:
Hi HN,
I built a small iOS app that performs text rewriting and summarization entirely on-device using Apple’s Foundation Models (iOS 18+).
Most AI writing tools rely on cloud APIs. That introduces API costs, privacy concerns, and infrastructure overhead. I wanted to explore what it looks like to build a useful AI writing utility with:
- no backend
- no external APIs
- no server costs
- fully offline support
The app can rewrite text in different tones, generate summaries, extract key points, and produce short post-ready output. Everything runs locally on supported devices.
Why I built it
I was curious whether on-device language models are “good enough” for everyday writing tasks like cleaning up emails, summarizing articles, or restructuring notes.
I also wanted to test a different economics model: since inference runs locally, marginal cost per user is essentially zero. That allowed me to avoid subscriptions and instead use a simple free tier with an optional one-time unlock.
Technical notes
- SwiftUI main app
- Share Extension for system-wide text processing
- Apple FoundationModels for local inference
- No networking layer
Some interesting constraints compared to cloud LLMs:
- Smaller context window
- More sensitive prompt design
- Device-dependent performance
- Latency perception is critical in extensions
On-device models are obviously less capable than large cloud models, but for constrained rewriting tasks they are surprisingly usable.
If anyone is experimenting with FoundationModels or on-device inference, I’d be curious how you’re handling prompt structure and long input segmentation.
App Store link:
https://apps.apple.com/us/app/rewrite-text-ai-writing-tool/i...
Happy to answer technical questions.

value: Show HN: Rewrite Text – On-Device AI Writing Tool for iOS


value: zihao-liu-qs

value: Show HN: Treekei – File Tree with Line Counts in CLI

author: zihao-liu-qs


value:
I built NetWatch because I wanted htop-style visibility into my network without leaving the terminal. It's a real-time TUI that gives you:
Live interface bandwidth with sparkline history
Active connections with process/PID mapping
Deep packet capture with protocol decoding (DNS, TLS/SNI, HTTP, ICMP, ARP, DHCP, NTP)
Wireshark-style display filters (tcp and port 443, contains "google", dns or icmp)
TCP stream reassembly with text/hex views
TCP handshake timing (SYN→SYN-ACK→ACK latency)
GeoIP and RDAP whois lookups
PCAP export
Protocol hierarchy statistics
Built with Rust, ratatui, and libpcap. Cross-platform: macOS, Linux, and Windows.
cargo install netwatch-tui
I've been in network/trading systems engineering for 20 years and wanted a tool that sits between netstat and Wireshark — something you can fire up in a second to answer "what's happening on my network right now?" without the overhead of a full GUI.
Feedback welcome — especially on the packet decoding and filter syntax.

value: Show HN: NetWatch – A Wireshark-style network analyzer TUI built in Rust


value: fengyiqicoder

value:
Hey HN,
I built PolyTell, a Chrome extension that uses AI to analyze news articles and tweets in real time, then surfaces relevant Polymarket prediction market odds directly inside the page — no tab switching required.
How it works:
Visit any news site or scroll your X/Twitter feed
PolyTell's AI reads the content, extracts key events, and matches them against live Polymarket markets
Inline cards appear right below the relevant content showing the market question, current odds, and a one-click bet button
For example, if you're reading an article about tariff policy changes, PolyTell will automatically find the matching Polymarket contract and show you the current price — all without leaving the page.
It supports both English and Chinese, and works with infinite-scroll feeds like X. In the demo video below, you can see it analyzing a news article (5 events matched), then switching to the X timeline where it picks up 10 events and generates 10 bet recommendations across tech, politics, and business categories.

value: Show HN: PolyTell-AI Chrome extension that shows Polymarket odds as you browse

author: fengyiqicoder


value:
Hey HN! This is a small side project I'm currently working on. With tspages, you can quickly host static websites on arbitrary hostnames in your tailscale network. This is useful for internal documentation or tools that don't warrant their own server or k8s deployment, for example. I was frustrated with the other options - hosting on one of the public providers like Cloudflare Workers or Vercel means having to lock down auth and hope you never screw that up; hosting on an internal web server means you can't have speaking Tailnet names.
So this is kind of a middle ground: tspages let's you create new static websites very easily, say `design-system.funky-animal.ts.net`: Simply drag-and-drop a folder, archive, or file or send it with curl, and the site will be up in a second. Deployments are archived, and you can easily switch to an older deployment via API or UI.
Since tailscale requests carry identity, tspages checks authorization to create, deploy, or view sites against your tailnet policy: You can use an app capability to create different permissions for users or tags. This also allows for some very basic analytics for hosted sites.
Finally, tspages allows to upload a config file alongside your assets to set some configuration parameters for the site, like enable SPA fallback routing, custom headers, or redirection targets.
This project is very young, so there might be some rough edges, but it does work, runs stable, and the capability system is sound. Let me know what you think!

value: Show HN: Tspages – static site hosting platform for your Tailscale network


value: tomstig

value: Show HN: Play Fun Clicker Game Online

author: tomstig

title: Show HN: Play Fun Clicker Game Online


value: jensec

value:
Hey HN, I built Clawned because I got mass downloading OpenClaw skills without reading a single SKILL.md. That felt stupid.
Turns out a lot of them are stupid and unsafe too having reverse shells, credential theft, prompt injection buried in configs people(and myself) blindly trust.
Clawned scans any skill before it touches your machine. 60+ threat patterns. Sub-2s. No signup. Paste a name or URL and go.
Already scanned 6,500+ skills. ~20% flagged as CAUTION or THREAT. That number honestly surprised me
Please give it a go and let me know how I can improve it

value: Show HN: Clawned.io Crowdsource public security scanner for OpenClaw skills

author: jensec


value: visiohex

value:
I built this because many citation tools return incomplete APA references (especially missing author/date -> n.d.), and users still have to fix everything manually.
This tool takes a URL or DOI and:
- extracts metadata with rule-first parsing
- uses AI to fill likely missing fields
- shows confidence + “needs review” warnings
- lets you edit and copy both reference + in-text citation quickly
Current focus is APA 7 for websites/DOI.
No-login usage is available for quick tests.
Would love feedback on:
1) citation accuracy edge cases
2) UI/UX clarity for review warnings
3) features you’d want next (BibTeX export, Zotero flow, etc.)

value: Show HN: APA citation generator that explains missing metadata

author: visiohex


value: semihcihan

value: Context Brief is an Open Source macOS menu bar app that captures high-signal context from the app you’re in (GitHub, Jira, Slack, Notion, web pages, and more) with ⌃⌘C, then pastes one clean, agent-ready brief with ⌃⌘V. Unlike copy-paste tools, it extracts beyond visible content, densifies noisy text, combines multiple snapshots into one task context, and keeps a local context library on-device.

value: Show HN: Capture context. Give your agent the full picture

author: semihcihan


value: Privacy First<p>Your data stays local. We don't collect chats or store API keys. Just provide a way to chat simultaneously.

value: Show HN: Secure Extension: Chat with ChatGPT and Other LLMs Simultaneously


value: wordsnaking

value: Show HN: Word Snake Puzzle

author: wordsnaking

title: Show HN: Word Snake Puzzle


value:
I built Verity, a Lean 4 framework for writing smart contracts, proving properties, and compiling to EVM bytecode.
Current status:
- 431 proven theorems
- 0 sorry
- 404 Foundry tests across 35 suites
- 5 minute quick start in the README
You can find the repo at https://github.com/th0rgal/verity , documentation at https://verity.thomas.md/ . I’d especially love feedback on:
1) proof ergonomics for contract specs
2) compiler output assumptions/trust boundaries
3) what would block real production adoption

value: Show HN: Verity, Formally verified smart contracts from spec to bytecode


value: xqli

value: Show HN: Mneme–Persistent memory for AI agents without vector search or RAG

author: xqli


value: Show HN: A 7-tier hybrid crypto stack (1553 Vigenèrepure-Python FIPS 203M-KEM)


value: kumaras

value:
Hey HN, I built SignForge as a free alternative to DocuSign/PandaDoc for freelancers and small businesses who just need to get documents signed without the $30/month tax.
How it works: Upload a PDF → drag signature/date/text fields onto it → send to signer via email → they sign with a link (no account needed) → you get the signed PDF with a full audit trail and verification certificate.
Tech stack: Next.js + FastAPI + PostgreSQL + PyMuPDF. PDFs are stamped server-side (image overlay, not AcroForm) so it works reliably on any PDF. Every signed document gets a QR code and cryptographic verification so you can prove it wasn't tampered with.
Also built 12 free PDF tools (merge, split, compress, watermark, etc.) that run entirely on the server with no file storage — processed and returned immediately.
Would love feedback on the signing UX and what features matter most for your use case.

value: Show HN: SignForge – Free e-signature tool, no account needed to sign

author: kumaras


value: Guardian-AI

value:
I’m an independent researcher building GuardianAI, a structural observer for AI systems.
This demo runs a strict deterministic contract test where the model must output exact literals. GuardianAI doesn’t judge correctness or inspect content — it observes trajectory behavior and surfaces failure signals when outputs breach constraints, emitting control states such as CONTINUE or PAUSE.
The interface shown is the visualization layer; the observer runs independently and can be tested via endpoint.

value: Show HN: A framework to observe epistemic drift in AI outputs

author: Guardian-AI


value: millionclicks

value:
Hi HN i built this as a small experiment in digital scarcity and early adopter dynamics.
There are 10,000 permanent text slots on a single page.
Each slot starts at $1. When someone claims one, they can add their own text (name, message, link, etc.).
As more slots are claimed, the price gradually increases.
There are no subscriptions or renewals its just a one-time purchase.
I’m curious how something simple like this behaves socially.

value: Show HN: A page with 10k permanent $1 text slots

author: millionclicks


value: aperi

value:
Hey hackers,
I made a CLI to sync your Codex prompts + agent reasoning + file diffs to a shared memory called Codaph (https://codaph.com). The goal was to sync agent activity across my team for a much richer understanding of the codebase.
Under the hood, it uses Mubit (https://mubit.ai) - memory engine we built based on associative retrieval. Mubit is built on the concepts of hypervectors and clustering (with time based decay for now)
Currently, Codaph works with Codex with plans to add other agentic tools soon.
Codaph is open source (vibe coded lol).
Would love to hear some feedback and if you want to try it Mubit is free (api key is available on https://console.mubit.ai)

value: Show HN: CLI for agentic activity tracking in Codex

author: aperi


value: Show HN: Interview-me – a Claude Code skill that interviews you before you code


value: machala

value:
I built Heroshot to solve a problem I kept hitting: documentation screenshots go stale and updating them manually is tedious.
With Heroshot you define what to capture in a JSON config (URLs, CSS selectors, viewports, light/dark mode), run `npx heroshot`, and get a browser with a visual picker. Click elements to configure captures, close the browser, run `heroshot capture`, and you're done.
Features that have been useful in practice:
- Visual picker - click elements on a live page instead of writing selectors by hand
- Per-domain element hiding - suppress cookie banners, chat widgets globally per domain
- Dark/light mode - captures both variants in one run
- Annotations - arrows, boxes, highlights baked into the PNG
- Native integrations for SvelteKit, Next.js, Nuxt, VitePress - components that serve the right variant (dark/light, viewport) automatically
- CI/CD ready - GitHub Actions workflow in one command
Two open-source projects adopted it: gander-tools/diff-voyager (replaced a custom Playwright script) and MRI-Lab-Graz/prism-studio (MRI research docs, even mentioned it in their JOSS paper).
Happy to answer questions about the design decisions.

value: Show HN: Heroshot – Define screenshots once, regenerate with one command

author: machala


value:
Hey HN,
I’ve been building LLM apps for a while, and one thing kept bothering me is that models will say completely wrong things with total confidence. Not edgy wrong or funny wrong, just confidently fabricated citations, broken reasoning, medical summaries that look plausible but aren’t. The kind of stuff that’s fine in a chatbot but sketchy in production.
So I built PsiGuard. It’s a lightweight SDK that wraps around your existing LLM call and scores the output for likely hallucination patterns. It returns structured metadata (confidence score, flags, anomaly signals) and lets you decide what to do — log it, warn, or block.
The goal isn’t to replace the model. It’s to add a safety layer.
Basic usage looks like:
from psiguard import monitor
response = monitor(llm_output)
print(response.score, response.flags)
It’s early, but it’s working well in my testing across general Q&A and domain-specific prompts.
Repo: https://bumpr-ai-safety-rafj.onrender.com/
SDK: pip install psiguard
I would very much appreciate feedback, especially from anyone running LLMs in production or dealing with hallucination mitigation in real apps.

value: Show HN: PsiGuard – real-time hallucination monitoring for LLM apps


value:
Hi folks! I know NES emulators have been implemented countless times, in practically every language imaginable.
However, having an LLM fully replicate the spec purely from memory—without referencing existing code—is still a significant challenge. It requires the underlying model to have strong anti-hallucination capabilities and solid long-term planning to keep from going astray. Because of this, building an NES emulator makes for an excellent LLM stress test.
Here is how the emulator was built:
Data Gathering: I asked Codex to download the necessary developer manuals and test suites. It was strictly prohibited from searching for reference implementations online.
Development: I instructed Codex to build the emulator until all test suites passed. This process was mostly hands-free; I only chimed in to encourage it to continue when it paused.
First Draft: After just 4-5 prompts, Codex delivered a functional, pure-Python emulator—though it ran at a sluggish 7 FPS.
Optimization: Asking Codex to optimize the app completely on its own didn't work this time. Instead, I had it generate a flamegraph, which identified the PPU update as the bottleneck. I then instructed Codex to rewrite the PPU in Cython without breaking the passing tests.
Overall, I'm incredibly impressed by Codex. I already knew it was capable of the task, but the speed was astonishing. It finished the project in under an hour, using merely 2% of my weekly Pro quota.
While the NES might be a relatively easy system to emulate, I think emulation could serve as a fantastic benchmark for testing future LLMs.

value: Show HN: Codex builds a working NES Emulator in one hour


value: Show HN: Who's Winning the AI Race?

title: Show HN: Who's Winning the AI Race?


value: SleepyJack

value: I made a trivia game for testing confidence calibration on data questions.<p>It presents AI generated questions with numerical answers. You submit your estimate and confidence level, and the game tracks your accuracy score plus whether you're over/under confident over time.

value: Show HN: A Confidence Calibration Game

author: SleepyJack

title: Show HN: A Confidence Calibration Game


value: bekacru

value:
Hey HN,
I’m Bereket, founder of Better Auth. Our team spends a huge amount of time on GitHub every day. Like anyone who’s spent enough time there, I’ve always wished for a much better GitHub experience.
I’ve asked a lot of people to do something about it, but it seems like no one is really tackling GitHub directly.
A couple of weeks ago, I saw a tweet from Mitchell (HashiCorp) complaining about the repo main page. That became the trigger. I decided to start hacking on a prototype to see how far I could push an alternative interface using GitHub’s APIs.
Within a week, I genuinely started using it as my default, same with the rest of our team. After fixing a few rough edges, I decided to put it out there.
A few things we’re trying to achieve:
- UI/UX rethink* – A redesigned repo home, PR review flow, and overview pages focused on signal over noise. Faster navigation and clearer structure.
- Keyboard-first workflow: ⌘K-driven command center, ⌘/ for global search, ⌘I opens “Ghost,” an AI assistant, and more.
- Better AI integration: Context-aware AI that understands the repo, the PR you’re viewing, and the diff you’re looking at.
- New concepts: Prompt Requests, self-healing CI, auto-merge with automatic conflict resolution, etc.
It’s a simple Next.js server talking to the GitHub API, with heavy caching and local state management.
We’re considering optional git hosting (in collaboration with teams building alternative backends), but for now, the experiment is: how much can we improve without replacing GitHub
This is ambitious and very early. The goal is to explore what a more modern code collaboration experience could look like, and make it something we can all collaborate on.
I’d love your feedback on what you think should be improved about GitHub overall.

value: Show HN: Better Hub – A better GitHub experience

author: bekacru


value: RossMorgan

value:
Hi HN,
I’ve been working on Grubl, an AI-powered cooking assistant focused on solving a surprisingly persistent problem: the daily “what’s for dinner?” decision.
Most recipe apps are essentially searchable databases. I wanted to experiment with something more adaptive — a system that combines LLM reasoning with structured recipe data and user constraints (budget, time, dietary preferences, household size).
Grubl currently supports:
Recipe generation from mood, cuisine, or available ingredients
“Fridge mode” (turn ingredients into meal suggestions)
Weekly meal planning with ingredient reuse optimisation
Auto-generated shopping lists
Nutrition-aware adjustments (macros per serving)
Step-by-step live cooking mode with timers
Basic taste preference learning
Some interesting implementation details:
Recipes are generated in structured JSON format rather than free text. This allows scaling, macro recalculation, cost estimation, and timer extraction.
Ingredient ontology mapping is used to normalise synonyms (“scallion” vs “spring onion”, etc.).
Meal planning attempts to reduce waste by reusing ingredients across days rather than treating each recipe independently.
User preferences are stored and used to bias generation weights (e.g., spice tolerance, disliked ingredients).
Things that turned out harder than expected:
Optimising weekly plans across cost, nutrition, time, and ingredient reuse simultaneously.
Making AI-generated recipes consistent enough for structured scaling.
Designing a UX that feels playful without obscuring control.
I’m particularly interested in feedback on:
Whether the structured + LLM hybrid approach makes sense architecturally.
How you’d approach long-term personalisation memory.
Whether narrowing to a specific segment (e.g. families or fitness users) would be smarter at this stage.
Site: https://grubl.app
Happy to answer questions about the stack, prompting, or tradeoffs.

value: Show HN: Grubl – AI and structured recipe generation

author: RossMorgan


value: Show HN: Neo – Turn any web app into an API by capturing browser traffic


value: coolapso

value: Show HN: Autobs – Translate "fix: null ptr" into "Enhanced platform stability"

author: coolapso


value: lakma

value: Show HN: I built an AI that turns emailed PDFs into ledger entries in 60s

author: lakma


value: zmactep

value:
Well, it happened. After endless release candidates, we've finally made it to v0.1.0.
What's inside:
GPU-accelerated rendering with WebGPU shaders, shadows, and goodies like silhouette edges and a special soft-light mode
Core operations run up to 1000x faster than the original PyMOL. Surface generation that used to send you on a coffee run now finishes the moment you hit the button
Full PyMOL selection algebra support — 95+ keywords, boolean logic, distance/expansion operators, slash-macros
Distance, angle, and dihedral measurements, atom labels — everything you need for structural analysis
Python API — from pymol_rs import cmd and you're right at home
PDB, mmCIF, BinaryCIF, SDF/MOL, MOL2, XYZ, GRO — read and write, automatic format detection, transparent gzip decompression
Scenes, movies, ray tracing — all on the GPU
Kabsch superposition, CE alignment, RMSD, DSS, symmetry across all 230 space groups
Out of PyMOL's 798 original settings, some number of them actually work. Nobody knows exactly how many, but it's definitely in the hundreds. Plus we've added new settings that the original never had — like per-chain surface generation
13 independent crates — if you're writing Rust, you can use just the selection parser, the file readers, or the full GUI. No monolith

value: Show HN: PyMOL-RS – Rust reimplementation of PyMOL with modern rendering

author: zmactep


value: pgebski

value: Show HN: HushWork – A focus environment with ambient sounds and timer in one tab

author: pgebski


value: soletta

value:
I watched Claude burn tokens reordering functions in a Rust file, removing each one and rewriting it in the new position, clogging its own context window in the process. I started doing the reorders manually, then paused. This is a closed problem: fully verifiable. A good fit for building quickly with an AI coding agent. So I did.
When an agent needs to move a struct above its impl block, or group related functions together, it has to delete and re-insert lines — tracking whitespace, comments, attributes, and hoping nothing gets lost.
rust-reorder parses the file with syn, assigns ordinals to every top-level item, and lets you move or reorder them. Comments and doc attributes travel with their items. A safety check verifies no non-empty lines were lost or duplicated.
Three commands: `list` (shows items with ordinals), `move` (relocate one item before/after another), `order` (full reorder by ordinal sequence).
Works fine for humans too, but the real use case is giving agents a reliable primitive for code organization.

value: Show HN: Rust-reorder – a CLI tool for reordering top-level items in Rust source

author: soletta


value: smalltorch

value: TerminalPhone is a single, self-contained Bash script that provides anonymous, end-to-end encrypted voice and text communication between two parties over the Tor network. It operates as a walkie-talkie: you record a voice message, and it is compressed, encrypted, and transmitted to the remote party as a single unit. You can also send encrypted text messages during a call. No server infrastructure, no accounts, no phone numbers. Your Tor hidden service .onion address is your identity.

value: Show HN: Terminal Phone – E2EE Walkie Talkie from the Command Line

author: smalltorch


value: Show HN: SpecLock – Constraint enforcement for AI coding tools (Bolt.new, Claude


value: sensecall

value: I sometimes work on projects without a content designer, so I made this for myself.<p>I often need to tidy up microcopy so it follows best practice. This is a small CLI that rewrites text into clearer, more user-centred GOV.UK-ish content, with an optional “why this is better” explanation.

value: Show HN: A tiny CLI tool for clearer Gov.uk-ish microcopy

author: sensecall


value: cschulze

value: Show HN: QuicFuscate – HTTP/3 VPN transport with adaptive FEC and stealth modes

author: cschulze


value: jkalamarz

value:
The tool I relied on got too expensive for me, so I built my own alternative.
It’s completely free and open source, and I’m sharing it in case it helps others here too.
If you try it, I’d love your feedback.
Feature ideas are very welcome. Please open an issue with what you’d like to see.
And if you find it useful, a star on the repo would mean a lot - that's my first open source commitment :)
THANKS!

value: Show HN: Zenshi – Google Search Console Dashboards

author: jkalamarz


value:
I use Claude Code, OpenCode, and Codex CLI every day. They're great at writing
code, but I have no idea what they're doing while they work. Tokens burn with no
visibility, context fills up silently, and when a session ends everything the
agent learned is gone.
Sidekick is a VS Code extension and standalone terminal dashboard that sits
alongside your AI coding agent and shows you what's happening in real time.
Try it:

  VS Code: search "Sidekick Agent Hub" in the extension marketplace
  CLI:     npm install -g sidekick-agent-hub && sidekick dashboard

It auto-detects
which agent you're running.
What it shows you:
- Live token and cost tracking with burn rate
- Full tool call timeline — every file read, write, bash command
- Session mind maps (force-directed graph in VS Code, tree in terminal)
- Destructive command alerts (rm -rf, force push, drop table)
- Decision log and knowledge notes that persist across sessions
- Session export to markdown, JSON, or text
It also does inline completions, code transforms, and commit messages using your
existing Claude subscription or API key — but the monitoring is the part I think
is missing from the ecosystem.
Works with Claude Code, OpenCode, and Codex CLI.
GitHub: https://github.com/cesarandreslopez/sidekick-agent-hub
Docs: https://cesarandreslopez.github.io/sidekick-agent-hub/
MIT licensed, TypeScript. Happy to answer questions about the architecture or
anything else.

value: Show HN: Sidekick – See what your AI coding agents are doing


value: clawshield

value:
As a heavy user of OpenClaw and various LLM clients, I’ve started noticing a disturbing trend: API providers are getting much better at "identifying" us. It’s not just about the API key anymore—it's your IP, your request timing, and your client’s specific HTTP fingerprint.
Anthropic’s recent reports on "distillation-pressure" and the community whispers about "silent" rate-limiting for specific IP ranges got me thinking: Why am I giving OpenAI/Google my home IP with every single prompt?
What I Built:
I built Claw Shield. It’s a privacy layer for OpenClaw (and potentially any OpenAI-compatible client) that implements Oblivious HTTP (OHTTP).
How it works:
Instead of a direct connection, Claw Shield uses a double-blind architecture:
The Client (OpenClaw Plugin) encrypts your request using HPKE.
The Relay (Cloudflare) sees your IP but cannot see your request content.
The Gateway (Your CF Worker) sees your request content but cannot see your IP.
The Model Provider sees the request coming from Cloudflare’s edge infrastructure, not you.
Why this is better than a simple VPN/Proxy:
Zero Trust: Even the Relay can't log your prompts, and the Gateway can't log your identity. You don't have to trust me or the relay provider.
Fingerprint Reduction: By standardizing the traffic through OHTTP/BHTTP, we strip away the unique signatures that providers use to identify "third-party client" traffic.
Open Source & Self-Hostable: Both the Relay and Gateway are lightweight Cloudflare Workers you can deploy in 1 click.
Status:
Verified working for Gemini and OpenAI. Supporting Anthropic and others via providerTargets.
Repo: https://github.com/xinxin7/claw-shield

value: Show HN: Anonymize LLM traffic to dodge API fingerprinting and rate-limiting

author: clawshield


value: overflowy

value: Show HN: Parallel rsync launcher with fancy progress bars

author: overflowy


value: postatic

value:
Hey HN.
I built Tablex (https://www.tablex.pro
), a web app to make wedding seating arrangements less painful (well any seating arrangement really).
My friend's getting married in September, thought I'd help him out knowing how it was a bit tricky to sort this all out.

value: Show HN: Tablex – Your wedding seat arrangement tool

author: postatic


value: siddhantminocha

value:
# Show Community: MIP - A Molecular Intelligence Platform for Biology Teams
Hi, Community!
I'm Sid, founder of Purna AI. We've been building a Molecular Intelligence Platform for the last few months, and now it's in research preview. It's a single workspace where molecular medicine teams can go from raw biology data to interpretation without juggling a dozen disconnected tools.
## The Problem
If you work in clinical genomics, rare disease research, computational biology, or similar fields, your workflow probably looks like this: export variants from one tool, look up annotations in another, cross-reference ClinVar, check gnomAD frequencies, read ACMG guidelines in a PDF, pull up a protein structure viewer separately, then paste everything into a report. Multiply that by hundreds of variants per case.
It's slow, error-prone, and most of the "analysis" time is actually spent on context-switching or copy-pasting existing scripts.
## What MIP Does
- *Singular Workspace for Biological Analysis* - Genetics, Epigenetics, Single Cell RNA, and more
- *AI-powered pipelines* - Can write complex pipelines, execute on a secure compute instance, and give you results in natural language
- *Variant analysis* with ACMG classification built in
- *Integrated with 30+ clinical databases* - ClinVar, gnomAD, OMIM, UniProt, etc.
- *Protein structure prediction with Chat* - Compare Wildtype vs Mutant Variations
- *AI-assisted interpretation*, reclassification, and reporting
- *Auditable Case Management* so nothing falls through the cracks
The AI layer is the key differentiator. We benchmarked it against 1,600 genomics queries from an Oxford dataset and hit 90%+ accuracy. But more importantly, it handles the kind of nuanced, multi-step reasoning that comes up in real casework, for example: "Is this VUS in a conserved domain?", "What's the functional impact given this patient's phenotype?", "Are there any recent publications reclassifying this variant?"
## The Backstory
I'm an engineer, not a biologist. We started building in the Preventive Healthcare (early diagnosis) space. Watching clinicians work with fragmented tools while making critical diagnostic decisions felt like a solvable problem. My co-founder Dr. Gitanjali (CMO) keeps us grounded in clinical reality.
## Where We Are
Early stage, two founders. We are now inviting scientists and biologists around the world to test more complex cases. We have already processed over 50 samples ourselves on the platform, and seeing PhD-grade results.
## What I'd Love From the Rainmatter Community
- If you work in *genomics, bioinformatics, drug discovery*, or similar fields, we'd love to give this to you and your team for early feedback.
- If you've built *developer tools or "IDE-for-X" products*: what did you learn about adoption in specialized domains?
- If you've done *B2B SaaS for life sciences*: any hard-won lessons on selling to labs and research institutions?
Happy to answer any questions about the tech, the biology, or the business.
*Check us out here:* purna.ai

value: Show HN: Molecular Intelligence Platform – Claude Code for Biology – Purna AI

author: siddhantminocha


value: mjankowski

value:
I built an open-source framework for validating decisions before AI agents execute them. It's called nSENS.
The problem it solves: AI agents are great at execution. Give them a spec, they ship code. But nobody checks whether the spec should exist. I spent 15 years in enterprise consulting watching teams build the wrong thing, and AI tools have made that failure mode faster and cheaper to reach - which means more of it, not less.
nSENS sits between "I have an idea" and "Let's build it." It has four main components:
1. Phase-gated validation (P0-P5) with hard kill gates. If you fail the gate, the idea dies. No sunk cost negotiation.
2. Adversarial review using 4 independent personas that attack your idea from different angles (business viability, evidence quality, complexity, problem intensity). Each produces numerical impact scores. In the test suite, a "Smart Fleet Energy Optimizer" enters at 0.87 confidence and exits at 0.43 with a DON'T BUILD recommendation. 11 issues found in under a minute.
3. Cognitive bias detection - 51 biases cataloged with pattern-matching rules. The system scans reasoning for indicators of biased thinking (confirmation bias, automation bias, sunk cost, anchoring, etc.) and flags them before the decision gets made.
4. A Prolog digital twin - this is the weird part. The framework includes a Prolog-based model that catches behavioral anti-patterns. Originally built to compensate for my own ADHD executive dysfunction (catching "starting project #4 when 3 are active" or "building when you should be selling"), but the pattern generalizes to any decision-maker profile. Prolog because formal logic doesn't hallucinate. When your validation layer is an LLM evaluating an LLM, you've added a confidence score to a confidence score.
Everything is in Python and YAML. The bias catalog and persona definitions are in YAML so you can fork them and adapt for your own domain without touching the engine. Decision audit trail in JSONL. MCP server integration for Claude-native usage.
Happy to answer questions about the Prolog angle, bias catalog, or anything else.

value: Show HN: NSENS – AI decision governance with Prolog and adversarial review

author: mjankowski


value: harrykoreanlee

value:
Hey HN! I work at a game company and after staring at code
all day, I didn't want to write more at night.
So I used Claude and Cursor to build this — architecture, design, infra, CI/CD. I just directed and reviewed. Took a few weekends.
It's a collection of tools I personally Google all the time:
  JSON formatter, image resizer, timestamp/timezone converters,
  UUID generator, QR code, and ~30 more.
Happy to answer questions about the AI workflow or anything else.

value: Show HN: I built this toolbox with AI – never wrote a line myself

author: harrykoreanlee


value: mnardelli

value:
Hi HN,
We built a FROST (RFC-9591) threshold Schnorr signature implementation as an extension module for libsecp256k1.
The goal wasn’t to make another framework but to see what it looks like when FROST is engineered inside a minimal, production-grade C crypto library.
Highlights:
- fork of bitcoin-core/secp256k1
- portable C89
- no external crypto dependencies
- RFC test vector compatibility
- upstream merges maintained
Mostly useful for embedded or performance-sensitive systems where adding a full crypto stack isn’t ideal.
Code:
https://github.com/bancaditalia/secp256k1-frost
Happy to answer questions or hear critiques.

value: Show HN: RFC-9591 FROST implemented as a libsecp256k1 extension (C89)

author: mnardelli


value:
We’re the team behind Revent, a B2B rental subscription platform for pre-owned electronics that supports partners and enterprises across the region - currently serving UAE and Saudi Arabia.
Originally our backend for business customers was a mix of WordPress and scattered plugins, and it quickly became a liability: fragile integrations, technical debt, and no clear scale path. So we rebuilt the system from the ground up on Replit and have been running it live for months.
What we built in ~3 months on Replit:
1. Admin dashboard with user management and customer profiles
2. Real-time subscription lifecycle with Stripe billing
3. Inventory control with serial number tracking
4. Quote generation → approval → checkout automation
5. Dynamic custom storefronts for partner businesses
5. Live deployment with zero downtime from old platform
Our B2B vertical is now the fastest-growing part of the business, and we’re shipping weekly features instead of wrestling with plugin conflicts.
Try it out:
https://replit.com/customers/revent

value: Show HN: Revent – Enterprise device subscription platform built on Replit


value: agreeablesnow

value: Show HN: Io Game to Clean the Earth

author: agreeablesnow

title: Show HN: Io Game to Clean the Earth


value: 20 years of code generation led here. The YAML 1.2 spec has 211 grammar productions. I converted them from the Haskell reference implementation to s-expressions, wrote a projector in Common Lisp, and generated spec-compliant parsers in 18 languages. All pass 308/308 YAML Test Suite tests. Adding a new language is a 300-line target spec. The projector does the rest in seconds.

value: Show HN: One grammar, 18 YAML parsers – a Futamura projector in Common Lisp


value: tskulbru

value:
Hi HN,
Some of you may have seen Mockingjay when I shared it in the "What are you working on?" thread [1] alongside my other projects (Kvile, Stao, MyVisualRoutine, and a couple more). The response and feedback there was great, so I wanted to do a proper Show HN.
Mockingjay is an iOS app for recording encrypted video that streams to your own Google Drive in real-time — so your footage survives even if your phone doesn't.
The problem: Journalists, activists, and witnesses recording in high-risk situations face a gap in their security toolkit. Signal protects messages, Proton protects email, but if someone confiscates or destroys your phone mid-recording, the video evidence is gone. Cloud photo sync is too slow and unencrypted.
How it works:
- Video is split into 3-10s fMP4 chunks during recording
- Each chunk is encrypted with AES-256-GCM (unique nonce per chunk)
- Chunks upload to your Google Drive over TLS while you're still recording
- Encryption keys live in the Secure Enclave, derived via PBKDF2 (600K iterations)
- A duress PIN wipes local keys under coercion — cloud backup stays intact, recoverable later on a new device
- C2PA Content Credentials embedded for cryptographic proof of authenticity (verifiable at contentcredentials.org)
- Panic-start via Action Button — recording begins with zero friction
Your footage goes to YOUR Google Drive, not our servers. We have no ability to access or recover your content.
The duress PIN was the hardest design decision. If someone forces you to unlock, entering the secondary PIN silently wipes the Secure Enclave keys. The attacker sees a "clean" state. Your encrypted cloud chunks are safe but inaccessible from that device. You recover later on a different device with your password.
Tech stack: SwiftUI, AVFoundation, CryptoKit, GRDB (SQLite upload queue with retry/backoff), Google Drive REST API, RevenueCat, SimpleC2PA.
Free tier: 60s recordings at 720p. Pro ($29.99 lifetime): unlimited recording, 1080p, GPS metadata, C2PA credentials.
If you're interested in my other projects from that thread — Kvile (Rust/Tauri HTTP client), Stao (sit/stand reminder), MyVisualRoutine (visual routines for kids), links are all in my earlier comment [1].
Would love feedback on the security architecture and threat model.
[1]: https://news.ycombinator.com/item?id=46945142
App Store: https://apps.apple.com/no/app/mockingjay-secure-recorder/id6...

value: Show HN: Mockingjay – Video recorder that encrypts and uploads as you record

author: tskulbru


value: tarasyarema

value: Show HN: Agent Swarm – Multi-agent self-learning teams (OSS)

author: tarasyarema


value: vulpez

value:
Honestly, I've been shipping a lot of AI-coded projects lately, and I've noticed more of them on HN too. But I always felt a little embarrassed posting mine here. Not because I think vibe-coding is bad(I do it myself), but it felt like I was presenting someone else's homework.
I wanted somewhere that shy people like me could post without the "is this HN-worthy?" pressure, and where the community could just be honest about it.
So I built this: https://shiporslop.xyz
Your AI agent reads a spec file, analyzes your current project, and submits it. Humans vote Ship(interesting) or Slop(not quite). That's the whole thing.
Give your agent this:
"Read https://shiporslop.xyz/SKILL.md and submit this project."
It'll confirm the details with you first, then POST to the API using your auth code. Works with Claude Code, Cursor, Windsurf, or whatever you're already using.
Half-finished projects are fine. A GitHub repo or any public URL works. No live deployment required. If you have literally nothing else, your GitHub profile URL counts. A real repo link helps people actually evaluate it, though.
GitHub login is required. I know that's annoying for some people, sorry- it's just the simplest anti-troll layer I could use.
Ranking is vote count + time decay, HN-style. No karma weighting.
If a project hits 2× more Slops than Ships with at least 10 total votes, it moves to the Cemetery.(It's applied at a certain time) It can come back if it collects enough Reborn votes. There are AI-generated epitaphs. It's a bit silly, but I like it. details in /guidelines.
About "Slop": yeah, it's a harsh word. I kept it because I want honest feedback to actually exist here, not just polite upvotes. The vote is supposed to mean "is this interesting?" not "is this production-ready?"
Nothing happens if nobody submits. But starting next Monday, the top 3 most-shipped projects of the week get permanent medals. It's still early. not much competition yet, if that matters to you.
No ads, no paid ranking. There's a Buy Me a Coffee link for server costs.
UI-wise it’s intentionally HN-like(almost a clone). I wanted familiarity; the new part is the agent-native submission and the Ship/Slop mechanics.
Anyway, I'd love feedback.

value: Show HN: Ship or Slop – AI agents submit projects, humans judge them

author: vulpez


value: devinda-dilshan

value:
Hi HN,
I made a simple web tool called SonicFlow (https://voice.clevermock.com) for converting text to an MP3.
I've used other TTS tools, but was looking for something with zero friction - no sign-up, no feature-gating, no complicated SSML tags to learn. Just a text box and a download button.
So I built it. It's a clean front-end that pipes text to a TTS model and serves the audio file directly. Useful for quickly listening to articles, comments, or maybe generating placeholder audio for a project.
It's free. Hope it's useful. Feedback is welcome.

value: Show HN: A minimal, no-signup, free text-to-speech tool

author: devinda-dilshan


value:
Hi HN,
I built a Blood Pressure tracker because I was tired of the existing apps requiring cloud accounts, subscriptions, or selling health data to advertisers.
BP Tracker Pro is a "Class I Data Logger" built with Capacitor and Vanilla JS. It runs 100% offline on your device.
Key Features:
- Gorgeous panel to visually track your blood pressure readings
- Zero Cloud Sync: Data lives in a local JSON store (encrypted at rest by Android OS). You can bacjup
- PDF Reports: Generates clinical reports for doctors using jsPDF (client-side).
- Morning Surge Detection: Analyzes AM vs PM readings to flag stroke risks.
- Family Mode: Track multiple profiles (e.g., aging parents) from one dashboard.
Tech Stack:
- Vanilla JS + Vite (No React/Vue overhead)
- Capacitor v8 (Bridge to Native)
- Chart.js for trends
https://play.google.com/store/apps/details?id=com.bloodpress...

value: Show HN: I built an offline-first, privacy-focused Blood Pressure tracker


value:
We asked Neo AI to build a small voice assistant pipeline that runs with low latency on CPU instead of requiring a GPU.
The goal was to see how responsive a LLM → speech system can be on normal laptops or edge devices.
It includes:
- Voice Activity Detection
- CPU-friendly LLM + TTS streaming
- Async pipeline to reduce latency
Modular LLM backend
Useful for local assistants, robotics prototypes, privacy-first setups, or benchmarking STT/LLM/TTS latency.
We’ve been experimenting with similar CPU-first pipelines inside NEO workflows for on-device agents, and this repo is a minimal standalone version.
Would love suggestions on lightweight STT/TTS models or latency tricks people have used on CPU.

value: Show HN: Kitten TTS Based Low-Latency Streaming Voice Assistant on CPU


value: yyusufaslan

value:
Hi HN,
While working on large Java projects, I often found myself digging through heap dumps and flame graphs just to answer a simple question:
Which methods are actually slow, and how much do they cost?
Traditional profilers are powerful, but interpreting the output takes time. AI tools can read source code — but they don’t see what happens at runtime.
So I built GalataJ.
GalataJ is a lightweight Java profiler that works directly inside IntelliJ (including Community Edition) and VS Code.
The workflow is simple: Profile → Compare → Act, without leaving the editor.
Profile
Bytecode instrumentation attaches to a running JVM (no restart required). It collects per-method execution time, call count, and memory allocation.
Metrics appear directly in the editor as CodeLens hints above your methods.
Compare
You can save profiling sessions and define baselines.
If a method becomes 30% slower compared to a previous run, you see it immediately — no dashboards or flame graph interpretation required.
Act
Profiling results are exported as structured Markdown files inside the project (.galataj/).
They are:
* Plain text
* Version-controllable
* Tool-agnostic
There’s also an “Add to Chat” action that sends the structured runtime data directly to the IDE’s built-in AI assistant.
Instead of describing a performance issue manually, you can provide actual execution metrics and let the AI reason with real runtime context.
The goal isn’t automation — it’s giving better inputs.
What it is not:
* Not an APM
* No distributed tracing
* No production monitoring
* No automatic deadlock detection
It focuses on one thing:
Helping developers understand runtime bottlenecks during development.
Would appreciate feedback from JVM and performance folks.
Happy to answer questions about the instrumentation approach or overhead trade-offs.
website : www.galataj.com

value: Show HN: GalataJ – Runtime-aware Java profiling inside IntelliJ and VS Code

author: yyusufaslan


value: marcomezzavilla

value:
A small social experiment.
You can give a positive or negative “aura” vote to public figures (living only).
The idea came from watching people obsess over rankings during a big music festival here in Italy. Since I wasn’t that interested in the show itself, I spent a few evenings building this instead.
Curious to see what the internet thinks.
(Hope I don’t get sued)

value: Show HN: Rate the Aura of Public Figures

author: marcomezzavilla


value: Show HN: ISC Core – Deterministic CI Artifact Attestation


value: Hughtopian

value: I was running Claude Desktop (Cowork) on a 462 file project folder. Claude reads every file at the start of each session, which burns context window on outdated and irrelevant docs. Output quality was degrading noticeably. Built a near-line tiering system: a manifest template per folder, global instructions for tiered access, and a Cowork skill for consistency. ~10 min setup. MIT licensed.

value: Show HN: Cowork Context Kit – tiered context management for Claude's file access

author: Hughtopian