value: md-adil

value:
Hi HN — I’m building Minima.js, a backend framework that tries to feel “native” to the platform by leaning into Web standards and keeping request/response handling close to the primitives (e.g., Request/Response style APIs), instead of inventing a big framework-specific universe.
Intro: https://minimajs.com/intro.md
The five core ideas I’m most excited about:
1. Runtime-Native Support - Built from scratch for Bun and Node.js with zero abstractions
2. Web Standard First - Uses native Request, Response, File, Blob, and Uint8Array throughout — no Node.js-specific buffers or proprietary abstractions
3. File-Based Modules - Your folder structure defines your API structure
4. Context Functions - Access request data anywhere without prop drilling
5. Everything is a Plugin - Hooks, middleware, auth—all follow the same pattern
Docs: https://minimajs.com
LLM-friendly docs index: https://minimajs.com/llms.txt
Would love feedback from people who’ve shipped production Node/Fastify/Express apps: does “web-standards + ALS-first context” resonate, and what would you want to see before trying it?

value: Show HN: Minima.js – a web-standards back end framework with req context via ALS

author: md-adil


value: ifeld

value: A visualization tool that shows the performance of 4 repayment strategies - standard, bi-weekly, extra payments, and velocity banking. Free, no signups, no tracking - hopefully a clean user friendly tool.

value: Show HN: I built a mortgage repayment strategy comparison tool

author: ifeld


value: pratikshadake

value:
I built AliveUI because adding meaningful motion to UIs with Tailwind is a second-class citizen. You reach for Framer Motion, write 40 lines of keyframes, or pile on JS runtime for something that should just be a class.
AliveUI treats depth and motion the way Tailwind treats spacing — as a primitive you compose, not a library you configure.
A few things that make it different:
Depth layers (d1–d3): One class gives an element physically correct elevation — shadow, border, background, and hover lift all update together.
Motion tokens: alive-enter, alive-enter-down, alive-enter-right, alive-enter-left, alive-enter-fade, alive-enter-scale are generated CSS keyframe utilities. Stagger is automatic via --alive-index. Zero JS runtime, works with any HTML.
Data-attribute interactivity: Accordion, modal, drawer, tabs, dropdown — driven by data-alive-* attributes and an optional 2KB runtime.
Arbitrary values: w-[340px], bg-[#ff6b6b] — same bracket syntax as Tailwind for escape hatches.
Setup is a PostCSS plugin, Vite plugin, or standalone CLI. Scans your source files, generates only what you use.
npm install @alivecss/aliveui
Site + live demos: https://aliveui.dev
GitHub: https://github.com/pratikshadake/aliveui
Curious what people think : is motion as a CSS primitive the right abstraction, or does it belong in JS?

value: Show HN: AliveUI – CSS framework with motion and depth as first-class primitives

author: pratikshadake


value: uchibeke

value: Show HN: We built a public CTF to stress-test AI agent guardrails

author: uchibeke


value:
ClawDaddy hosts OpenClaw AI agents, which you can set up and deploy by chatting with one on Telegram.
I grew tired of the complicated OpenClaw setup process—Node, Docker, BotFather, gateway pairing, authentication configurations, and security patches. So I decided to let an agent manage all that for you. Each agent operates on its own server rather than a shared container.
Try @clawdaddyrunbot on Telegram—your feedback is welcome.

value: Show HN: ClawDaddy – Deploy OpenClaw by chatting with one on Telegram


value: mtford

value: httap is a powerful HTTP proxy for your terminal. Intercept, inspect & rewrite HTTP traffic — from your shell or your AI agent.

value: Show HN: Httap – intercept and inspect HTTP traffic from your shell or agent

author: mtford


value: deevus

value:
Pixels provisions Incus containers onto your TrueNAS server using their websocket API. I took inspiration from https://sprites.dev/. I have been doing a bit of vibe coding recently, but I didn't want to pay for a sandbox product. It's supposed to be simple to startup a container and get into a console. The most popular agent CLI's that I could think of are already installed if you provision with `devtools = true`.
I used Claude Code extensively but this is NOT vibe coded! I review every line of code. I might have missed some corkers when developing this at midnight.
It is using a bit of trickery to support checkpoints of the Incus containers. The main reason for this was so that you can spin up a base container, install everything you want, and then create a new container from that.
I did try to make the sandbox secure. I think I can do a better job there. Opus is actually pretty good at escaping a sandbox if you ask it to. Read the details in SECURITY.md.
In future I would like to provision the base container as part of the setup, to help speed up subsequent creates.
I'm not totally sold on the name. It was just the first thing I thought of. I don't know if this is even something others would want to use, but it scratches an itch for me.
---
A bit of backstory:
Over the last couple of months I have been working on a Terraform provider for TrueNAS SCALE [0] and it occurred to me that all this work could be extracted into a client library [1]. I wanted to play around with vaxis [2], so I created a basic TUI that you can use to monitor your TrueNAS server [3].
[0]: https://github.com/deevus/terraform-provider-truenas
[1]: https://github.com/deevus/truenas-go
[2]: https://github.com/rockorager/vaxis
[3]: https://github.com/deevus/truenas-tui

value: Show HN: AI sandbox that runs on your homelab

author: deevus


value: chrisweiindie

value:
Hi HN! I built Kaomojiya (https://kaomojiya.org), a free kaomoji reference site with 3,000+ Japanese emoticons organized into 500+ categories.
The idea came from wanting a fast, well-organized way to find and copy kaomoji — those uniquely Japanese text emoticons like (╥﹏╥) and ٩(◕‿◕｡)۶ that you can't easily type.
Features:
- One-click copy to clipboard
- 500+ categories: emotions, animals, characters, greetings, seasonal, food, etc.
- Subcategory filtering (basic, cute, kawaii, decorated, ascii art)
- AI-powered kaomoji generation for custom ones
Tech stack: Next.js 14 (App Router), Tailwind CSS, Shadcn UI, deployed on Cloudflare Pages. Each category is a static TypeScript data file with kaomoji,tags, and popularity scores — no database needed for the main content.
The tricky part was organizing 300+ data files by category while keeping Japanese cultural context intact (e.g., dogeza, banzai, otsukaresama have specific meanings that don't translate directly).
Everything is free, no signup required. Would love feedback on the UX and category organization!
https://www.kaomojiya.org/

value: Show HN: Kaomojiya – Browse and copy kaomoji (Japanese text emoticons) instantly

author: chrisweiindie


value:
Hello,
I built a Caddy middleware that implements the x402 protocol (by Coinbase) to charge AI crawlers real money for content access.
When GPTBot, ClaudeBot, or any known AI crawler hits your site, it gets an HTTP 402 with payment
  requirements. If it pays (USDC on Base), it gets the content. If not, it gets nothing.
Normal users are never affected.
How it works:
  - Crawler detected by User-Agent → 402 response with price and wallet address
- Crawler signs a USDC payment (EIP-3009) and retries with X-PAYMENT header
- Plugin forwards to x402.org facilitator → on-chain settlement on Base
- USDC goes directly from crawler's wallet to yours
- Content served

  Configuration is a few lines in the Caddyfile:

      x402 {
          pay_to  0xYOUR_WALLET
          price   0.05
          network base
          exempt  /robots.txt
      }

  It's running on my site right now. No payments yet since most crawlers don't support x402, but they get blocked with a proper 402 instead of getting free content. When they do adopt it, the infrastructure is ready.

Built with pure Go (no CGo), SQLite audit trail, Cloudflare-compatible headers.

value: Show HN: Caddy plugin that charges AI crawlers real USDC to access your site


value: VanceVP

value: Show HN: AI powered OSINT platform for Brazilian due diligence

author: VanceVP


value: sebrindom

value: Show HN: I built a marketplace to see if OpenClaw bots can make money

author: sebrindom


value: cdnsteve

value:
I built this because I wanted a fun way to practice incident debugging without the stress of an actual outage.
You get a production incident scenario, read through logs and metrics, and figure out what went wrong. 9 scenarios so far across beginner to advanced.
Built with Next.js. Free to play, no signup required to try it.
Would love feedback on the scenarios - especially if you've dealt with real incidents that would make good puzzles.

value: Show HN: You Broke Prod – A game where you debug production incidents

author: cdnsteve


value: juanre

value:
I’m building what I hope will be sane agent-to-agent communication.
Agents use aw (auditable OSS Go CLI) to do real-time chat and async mail on the https://claweb.ai network. ClaWeb is built on the open aWeb protocol: https://github.com/awebai/aweb.
Each agent has an address (e.g. claweb/marvin) and a self-certifying signing identity (did:key). Messages are signed and verifiable offline. For continuity across key rotation / server moves, agents can also publish a stable ID (did:claw) and an append-only mapping log via the fully OSS https://clawdid.ai registry.

value: Show HN: OSS Go client for signed agent-to-agent messaging in the ClaWeb network

author: juanre


value: Falimonda

value: Show HN: TAS – Tracking, Automation, and Skills for Claude Code

author: Falimonda


value:
For Pokémon Day, I wanted to show something small and fun. I made PokeInvasion, a Chrome extension that makes Pokémon appear while you are browsing the web. They pop up from corners on any website when the extension is activated.
It's mostly a fun experiments for those fans like me who always want to catch Pokemons!
Source code:
https://github.com/IvanR3D/pokeinvasion_chrome-extension
Would love feedback, ideas, or suggestions for fun improvements.
Happy Pokémon Day! :)

value: Show HN: PokeInvasion – Wild Pokémon appear on every website


value: knuckleheads

value: Show HN: Globs – a daily puzzle about finding the hidden connections

author: knuckleheads


value: Show HN: Sugar – A task queue that lets AI coding agents work autonomously


value: Show HN: A Spatial Alternative to Timeline-Based Digital Memory


value:
RetroTick parses PE/NE/MZ binaries, emulates an x86 CPU, and stubs enough Win32/Win16/DOS APIs to run classics like FreeCell, Minesweeper, Solitaire and QBasic, entirely in the browser. Built with Preact + Vite + TypeScript.
Demo: https://retrotick.com
GitHub: https://github.com/lqs/retrotick

value: Show HN: RetroTick – Run classic Windows EXEs in the browser


value: sakibulefty

value:
I got tired of checking multiple job boards every morning so I built OpportuAI.
It automatically scrapes 277+ remote jobs daily from 8 sources (Remotive, RemoteOK, We Work Remotely, HN Hiring, Wellfound, NoDesk, Arbeitnow, Jobicy) and aggregates 159+ AI tools from Product Hunt, BetaList, and Reddit.
Stack: React + Vite, Vercel (free tier), Supabase, Python scrapers hitting public APIs and RSS feeds.
Also has a submit page if anyone wants to list their tool or job: opportunai.vercel.app/submit
Would love feedback from this community!

value: Show HN: OpportuAI – remote jobs, AI tools and digital products aggregator

author: sakibulefty


value: Pouryaak

value: Show HN: LokulMem – Local-first memory management for browser LLMs

author: Pouryaak


value: bpds

value:
Hi HN,
I've been obsessed with metaprogramming and generative systems since 1998.
With the rise of AI agents that actually write code, I felt the time was
right to formalize an idea I've been circling for years: Organic Programming.
The premise is simple: a single .proto file (Protocol Buffers) is the
universal contract between every component in your system — old code, new
code, human-written, agent-generated. From that contract, everything else
is automatically generated: API stubs, CLI wrappers, client/server
skeletons, serialization. You write only the domain logic.
The building block is the "holon" — a composable unit at any scale that
exposes multiple facets (gRPC service, CLI tool, library API, tests), all
derived from the same .proto. Holons compose in-process, over the network,
or at the shell (classic Unix piping). Two holons from different tech stacks
interlock like LEGO bricks — one serves, the other dials.
It's bio-inspired (small autonomous units that compose into larger
organisms) and Unix-inspired (everything pipes, do one thing well).
What exists today:
- A specification ("seed"): constitution, protocol, conventions
- SDKs for 14 languages (Go is the reference, others at various stages)
- Hello-world examples in 12+ languages
- A cross-language Go+Dart assembly demo
- CLI tooling (op, who)
Repo: https://github.com/organic-programming/seed
Org: https://github.com/organic-programming
About me: https://pereira-da-silva.com/en
I'd love honest feedback — especially from anyone wrestling with
composability in the age of agentic software.

value: Show HN: Organic Programming – A .proto is all you need

author: bpds


value: AdityaKasaudhan

value:
Hey HN, I built this because I was tired of writing custom scrapers for every website. Browse2API records your browser interactions and turns them into production-ready API endpoints. You can try the live demo APIs on the page - no signup needed.
Looking for early users who want custom APIs built for their use case. I'd love any feedback or suggestions on the product, the demo APIs, or use cases you'd want supported.<p>Happy to answer questions!

value: Show HN: Browse2API – Turn any website into an API

author: AdityaKasaudhan


value: dikshantjoshi

value:
A year ago, I couldn't code. I still can't. But AI coding tools got me
here.
If you use Claude Code on anything bigger than a small script, you've
hit the token limits faster than you'd like, or experienced context rot
mid-session. The agent loses track of files, forgets architecture
decisions, starts making things up. I was hitting this every single day.
DevSquad is a Claude Code plugin, not a framework, not a new CLI. You
install it, and it hooks into Claude Code's execution to delegate
subtasks to Gemini and Codex. When context gets heavy, specific work
gets offloaded: tests to one model, docs to another, refactoring to a
third.
For a quick proof of concept, I initially made a Claude.md that did the
job, but I had to often remind it and it wasn't predictable or
reliable. Hence, hook-enforced delegation, not polite suggestions via
Claude.md. The plugin intercepts at defined trigger points and routes
work through structured handoffs. Each agent operates in a focused
context window instead of everyone fighting over one.
I know what you're thinking: there have been a dozen agent
orchestrators on Show HN this month. Here's why I built another one: all of those require
you to set up a new environment. Docker, new CLI, YAML configs.
DevSquad hooks into the tool you already use.
How I built it: I'm a product person, not a developer. I led product at
an AdTech company for years but never wrote production code. DevSquad
was built entirely with AI coding tools — Claude Code, Google
Antigravity, and yes, DevSquad itself once the early version worked.
Make of that what you will.
Two questions I'd genuinely love HN's take on: How are you handling
Claude Code's token limits on large projects? And — right now this is
built for vibe coders. Does it matter if the person who built a tool
can't write the code by hand, as long as the tool works?

value: Show HN: DevSquad – Claude Code Plugin That Works with to Gemini CLI and Codex

author: dikshantjoshi


value: sentriflow

value: Show HN: NexTerminal – A Unified SSH, Serial Manager for VS Code

author: sentriflow


value:
Hi HN, I’m sharing OneSentence, an offline voice utility for macOS (M-series). I built this for two reasons: first, I wanted to see how far I could push cheap AI, and second, I wanted to use this utility. The idea was born out of using Emacs packages with Whisper to dictate to my machine. I had found it effective to simply speak and articulate context to coding agents. OneSentence does four things well: privacy, speech-to-text, text-to-speech, and template insertion.
The development process was probably the most interesting part. I used Gemini 3 Pro Preview and 3 Flash Preview almost exclusively (yes, it was not Claude). It went from chatting to writing light specs and decomposing to tasks, to finally setting up a Ralph-style orchestrator that I would leave running overnight. I also had not a few of late nights; making progress this way was exhausting, but still fun. It's not something I ever would have built without AI. The models helped me maintain strict linters, achieve upper-80s test coverage, write the Cloudflare services, and walked me through the maze of Apple's sandboxing, certificate provisioning and signing. End to end, everything was made through Gemini, down to the scripting and recording of the promo video. The linter became a quality-of-context goad. Yes, I really do want explicit type interfaces even through Swift does fine without them, and no you will not write more than 800 lines of code in a file.
Pain points: The UI tests are slow, test logs flood context, and the AI hallucinates (who knew). Cloning lib code into tmp/ to answer questions became a habit.
Under the hood, it relies on a sizeable set of technologies. It feels like the whole thing is like Aesop's polite gnat that rested on a bull. In other words: built on the shoulders of giants. Georgi Gerganov, Hyeongju Kim, Steve Yegge, Sindre Sorhus, Gwendal Roué, Zorg, the team who made Whisper, and so so many others: you have my thanks.
The app is built in Swift, it uses Whisper.cpp and ONNX for inference and supports Whisper and Parakeet for speech-to-text and uses Supertonic text-to-speech. I got to try a few new (to me) tools: Prek for pre-commit hooks, Tuist for project generation, dvc for model versioning and management, beads for agent work tracking, et.al. Gemini converted raw Whisper .pt files to CoreML using PyTorch, and I spent a lot of time experimenting to see how much of a difference using the Apple Neural Engine would make (interestingly, not as much as I expected in my use case, but both modes work). Parakeet is also in there just for kicks (Whisper produces better results).
I originally planned to launch on the Mac App Store, but the reviewers insisted I remove a behavior I felt was central to the app. So instead I decided to distribute it directly, using Cloudflare Workers/R2, and LemonSqueezy for sales & licensing.
Supertonic's diffusion models are interesting to use; they never read a text exactly the same way twice. If you do decide to try OneSentence, just for fun, turn off the "Refine Punction" setting and see what happens when you have it read a sentence with lots of exclamation marks, my boys got a kick out of it.
I set the defaults for myself. Transcription defaults to Whisper Large V2—which is relatively old, large and slow, but I found the transcription quality excellent.
I am offering this primarily as a one-time purchase, But there is also a cheap subscription option there if people prefer it. I know there are other product options, other models, and even macOS's own functionality. Choice is good.
This has been my evenings-and-weekends project for the last several months, and as a daily driver, I get a lot of value out of it.
You can check it out here: https://onesentence.app/  Use the promo code I3MDE1MQ to get 40% off in the next two weeks.
I'll be around to answer any questions.
Cheers!

value: Show HN: OneSentence – An offline macOS voice utility built entirely with AI


value: AliThink

value:
Hi HN,
I built NightClear because during the day I'm productive. At night, my brain becomes a worst-case-scenario simulator.
Based on CBT's "structured worry time" — instead of suppressing anxious thoughts, you give them a container:
1. Type what's on your mind (free-form, private)
2. LLM analyzes: core issue, controllable vs not
3. Generates one micro-action for tomorrow
4. Breathing exercise
SwiftUI, SwiftData (local), LLM API. Dark mode only. No account needed. No social/gamification.
Free: 3/week. Pro: $4.99/mo or $29.99/yr (7-day trial).
iOS only. Would love feedback on the AI analysis quality.

value: Show HN: NightClear – AI anxiety clearing for bedtime

author: AliThink


value:
Hey HN,
I've been building Splox for 2 years — autonomous AI agents that connect to your tools and act on your behalf. Before OpenClaw, before the hype.
You describe what you want in plain English. The agent executes it across 10,000+ services via MCP with 1-click OAuth. No LLM keys to manage, no Docker, no self-hosting.
Three agents live today:
- Autonomous Trader — connects to Hyperliquid, monitors markets, executes positions, manages risk. Runs 24/7.
- Omni Tool Agent — email, Sheets, Notion, Slack, Telegram — anything you'd waste 2 hours on daily. 10,000+ tools via MCP.
- Coder — connects to your servers, local machines, Kubernetes clusters. Reads codebases, deploys, manages infrastructure end-to-end.
People are using it to manage social media accounts, run Telegram user bots, automate customer support — all by just connecting a tool. No code required.
What makes it truly autonomous: a built-in Event Hub. Agents
subscribe to real-time events — webhooks, scheduled triggers, even detecting silence — and react without human input. They run indefinitely.
For power users, there's a visual graph-based workflow builder for complex multi-step pipelines: https://app.splox.io
You can deploy your own complex AI Agents by using graph-based workflows.
For end users:
https://chat.splox.io
Would love feedback.

value: Show HN: I've been building autonomous AI agents for 2 years – before OpenClaw


value: markaroo

value:
We’ve been building out the usage-based billing for Tonic Fabricate, and I ran into a Stripe limitation that isn’t really advertised but can completely break your checkout flow if you’re doing multi-model AI billing.
Like many AI-native applications, Fabricate supports a variety of LLMs (Sonnet, Haiku, Opus, etc.) for various agents and tasks. Users pay for usage by the token. We’d love to use Stripe Billing Meters to charge users by the token — I trust Stripe’s math more than my own when it comes to floating point arithmetic with very large numbers.
But Stripe caps subscriptions at 20 items. Each meter requires its own price, which in turn consumes one of those 20 item slots.
This becomes a problem fast with AI. If you multiply 4-5 models by 5 token types (input, output, cached input, and ephemeral cache tiers), you’re already at 20+ meters. Adding even one more model exceeds the limit.
The workaround we settled on was to move the pricing logic entirely into Fabricate and report abstract "billing units" to Stripe instead of raw tokens.
The setup is pretty simple:
1. We created one single meter in Stripe with a fixed price of $0.00000001 per unit.
2. Internally, we assigned an integer multiplier to every model/token combination (e.g., Sonnet input might be 350 units per token, while Haiku cached input is 10).
3. At reporting time, we do the integer math: (tokens * multiplier) for each category, sum them up, and send that one aggregate number to Stripe.
This effectively decouples our model list from Stripe’s API constraints. We can add as many models or token tiers as we want without ever touching Stripe configuration again.
The obvious downside is that the Stripe dashboard just shows a massive number of "units" rather than a breakdown of what the customer actually used. We decided we didn't care. We have our own internal telemetry for usage analytics; Stripe’s only job is to multiply a number by a price and generate a valid invoice.
If you’re setting up usage-based billing with more than a few dimensions, I’d recommend abstracting your units from day one. It’s much easier than trying to migrate your billing architecture once you’ve already hit that 20-item ceiling. And of course if you're Stripe (hi, Stripe!), I really recommend making changes to your product to offer native support for this very popular use case.

value: Show HN: Bypassing Stripe's 20-item limit for multi-model AI billing

author: markaroo


value: junetic

value:
Figma plugin that uses LLMs to critique UI clarity and hierarchy.
Includes a “roast” mode for blunt feedback.
Interested in honest reactions.

value: Show HN: I built an AI that roasts your Figma UI

author: junetic


value: faryalbukhari

value:
Hi HN,
I built ProfitPilot after noticing many online sellers price products using incomplete marketplace calculators or spreadsheets.
Most tools show platform fees but ignore advertising costs, returns, taxes, and target profit planning — which means sellers often discover real profit only after listing.
ProfitPilot focuses on pre-listing decisions:
• calculate true profit and margin
• reverse pricing from target profit
• test multiple pricing scenarios quickly
It’s intentionally simple and platform-independent.
Would really appreciate feedback — especially from anyone selling online or working in ecommerce tooling.

value: Show HN: Pricing calculator for marketplace sellers (Amazon, Etsy, eBay)

author: faryalbukhari


value: grayguava

value:
I built ByteSeal because I wanted a simple way to encrypt files
without trusting any server.
it runs entirely in the browser:
- no uploads
- no backend
- works offline
the container format is simple and versioned so files can be
decrypted later even if the UI changes.
demo:
https://byteseal.pages.dev
feedback welcome.

value: Show HN: ByteSeal – offline browser-based file encryption (no uploads)

author: grayguava


value: ffsoftboiled

value:
I’m a teacher, not a professional developer. I’ve been trying to track my fishing life-list in Excel for the last year, but it was clunky and I eventually gave up.
I wanted to show my students that the "technical wall" shouldn't stop them from building tools they actually need. I "vibe coded" this entire app in about a day using AI to handle the syntax while I focused on the logic and the user experience.
The Goal: To prove that with modern tools, you can move from "spreadsheet fatigue" to a functional, custom application without a CS degree.
The App:

    100% Local: No sign-ins, no databases, no tracking. It uses IndexedDB to keep data on the device.

    Offline First: It’s a PWA, so it works on the water where there’s no signal.

    Open Source: I’ve put it under an MIT license so my students (and anyone else) can fork it and break it to see how it works.

I’d love feedback—not just on the code (which I know is AI-assisted), but on the utility. Is this a viable way to teach "Creation over Consumption" to the next generation?

value: Show HN: FishDex An offline fishing log built to show my students

author: ffsoftboiled


value:
UK water providers publish tap water quality data, but it's scattered across 18 different websites, buried in PDFs, and difficult to decipher. Here you can find it in a easy to get format.
Enter your postcode and get readings for lead, copper, iron, nitrate, hardness, chlorine, pH and fluoride.

value: Show HN: I scraped 25 UK water companies to grade your tap water by postcode


value: lineudemonia

value:
I subscribe to 23 paid investment newsletters on Substack (~$9,600/year). I couldn't keep up with reading them all, so I built a system to extract and evaluate every stock pick.
*The pipeline:*
- Crawls articles from Substack
- Extracts high-conviction stock picks using Gemini's structured output — filters out casual ticker mentions and only counts calls where the author dedicates real analysis, specific data, or price targets
- Tracks returns at 1d, 7d, 15d, 30d, and 60d post-publication using yfinance
- Calculates alpha vs sector-specific ETF benchmarks (SOXX for semis, IGV for SaaS, XLF for financials, EWJ for Japan, SPY as fallback)
- Deduplication: same author, same ticker within 14 days = one call. Cross-author calls are independent
Total dataset: 3,519 high-conviction calls from 22 authors over 1 year.
*Interesting technical challenges:*
1. AI extraction accuracy. Gemini is surprisingly good at identifying whether an author is making a real call vs. just mentioning a ticker in passing. We tag calls with conviction level (high/low) and direction (bullish/bearish). To validate this, we spot-checked against manual reads and cross-verified with alternative model outputs. Not perfect, but consistent enough to be useful.
2. Custom domain handling. Many Substack authors use custom domains (e.g., collyerbridge.com, lordfed.co.uk) which sometimes trigger Cloudflare challenges. We fall back to headless Playwright when the standard HTTP client gets blocked.
3. Benchmark selection. A naive "did the stock go up?" metric is meaningless in a bull market. We map each ticker to a sector ETF benchmark, so alpha = position return minus benchmark return over the same period. This separates genuine stock-picking skill from just being long in a rising market.
4. Deduplication logic. Authors often revisit the same thesis across multiple articles. Without dedup, a single stock mentioned in 5 articles would count as 5 independent "calls." We use a 14-day window per author per ticker — only the first mention counts.
*Some findings (for context, not the point of this post):*
- Top performer averaged +14.9% at 30d and +26.7% at 60d on long calls
- The most expensive newsletters ($1,000+/year) were not the best performers
- Authors with fewer, more targeted calls (15-80) tended to outperform those with 300+ calls
- 30d vs 60d rankings shift significantly — deep value investors look much better at longer horizons
- Short calls were harder for almost everyone
*Stack:* Python, SQLite, Gemini API (structured output), yfinance, Playwright (optional)
I wrote a more detailed breakdown with charts as an X thread: https://x.com/pyhrroll/status/2027374283669066045?s=20
Happy to discuss the methodology, architecture, or share the extraction prompts. The pipeline is ~2,000 lines of Python if there's interest in seeing the code.

value: Show HN: I tracked 3,519 stock picks from 23 Substacks – who makes money?

author: lineudemonia


value: voska

value: I wanted my agent to be able to give me insights into my financials and handle some of the accounting tasks in a context-efficient way, so I built `qbo-cli` to interface with Quickbooks Online.<p>Heavily inspired by steipete's CLI tools.

value: Show HN: qbo-cli - Quickbooks CLI for AI Agents

author: voska


value: intellegix

value: Show HN: Intellegix – Autonomous Claude Code toolkit with loop driver and MCP

author: intellegix


value:
I built Stash, a self-hosted bookmark manager that uses AI to automatically process your links.
Paste a URL and it fetches the content, parses it, summarizes it, auto-assigns categories and tags, and generates a vector embedding for search.
Search is hybrid — it combines pgvector cosine similarity (semantic) with PostgreSQL tsvector (keyword) and merges both with Reciprocal Rank Fusion. You can search in natural language ("articles about distributed systems tradeoffs") or with simple keywords.
It's single-tenant by design: one password, no user accounts, no tracking. Your data stays on your machine.
The project is MIT licensed don't hesitate to contribute. Some areas where help would be great: browser extension, bookmark import/export
GitHub: https://github.com/ayoub9360/stash
Happy to answer questions about the architecture or the hybrid search approach.

value: Show HN: Stash – AI-powered self-hosted bookmark manager


value:
Hey HN, I'm a solo developer and I built Steps: Workout & Pedometer, an iOS pedometer and workout tracker.
Last week, two German iOS publications wrote about the app. I didn't pitch them. I didn't send a press release. I didn't even know it was happening.
I woke up to a spike in downloads, checked the analytics, and traced it back to their articles. That coverage pushed the app past $1,000 in sales.
I still have no idea how they found the app. I'm wondering if anyone here has experience getting featured in publications, whether organically or through outreach. What worked for you? Any tips for a solo dev trying to get more press coverage?
Here are the links to the articles:
- https://www.iphoneblog.de/2026/02/21/steps-visualisiert-das-...
- https://www.iphone-ticker.de/schrittzaehler-mit-mehrwert-com...

value: Show HN: My app got featured in 2 German publications and crossed $1K in sales


value: stevedcc

value:
I built tswap after noticing that Claude Code, while genuinely useful for managing a Kubernetes cluster, was pulling plaintext secrets from every manifest it touched. I wanted the AI to be able to do its job without ever seeing the actual values.
tswap keeps secrets in an AES-encrypted vault file on disk. The decryption key is derived from a YubiKey via HMAC challenge-response. At init you pair two YubiKeys — either unlocks the vault, so you have no single point of hardware failure.
Config files use a comment-based placeholder that keeps them valid YAML:

    stringData:
      DB_PASSWORD: # tswap: db-password

Deployment is a pipe:

    tswap apply values.yaml | helm upgrade myapp ./chart -f -

The privilege split is the key design decision: `apply`, `run`, and `check` need no elevation (AI agent gets these). `get`, `list`, `delete`, and `export` require sudo/admin (human gets these). The AI can deploy; it can't read or enumerate secrets.
Other features: burn tracking for rotation, `redact` for stripping values from logs, `check` for pre-deploy validation, `export`/`import` for vault migration.
Single binary, no daemon. Tested on Linux, macOS, and Windows.
https://github.com/stevedcc/TokenSwap

value: Show HN: Tswap–Yubikey-backed secret injection for IaC and AI-assisted workflows

author: stevedcc


value: Index COG metadata once into Parquet, skip cold starts forever. Filter with DuckDB, train with TorchGeo, fetch pixels on demand. 20x faster runs

value: Show HN: Rasteret-library for fast table like access to Satellite Imagery


value: vhalasi

value:
Hey HN! We built Crewship (https://crewship.dev) because deploying AI agents to production is still unnecessarily painful.
If you've built something with CrewAI, LangGraph, or similar frameworks, you know the drill: it works great locally, then you spend days figuring out infrastructure, scaling, monitoring, and artifact management just to get it running for real users.
Crewship handles all of that. You add a crewship.toml to your project, run `crewship deploy`, and your agents are live in seconds. It's framework-agnostic — we currently support CrewAI, LangGraph, and LangGraph.js, with more coming.
What you get:
- One-command deploy (no Docker/K8s config needed)
- Real-time streaming of agent actions via SSE
- Automatic artifact collection (every file/report your agents produce)
- Auto-scaling from zero to thousands of concurrent runs
- Version control with instant rollback
- Secrets management
We're a small team in Switzerland, and we've been using this ourselves for months. Free tier available — would love your feedback.
Docs: https://docs.crewship.dev
Quickstart: https://docs.crewship.dev/quickstart

value: Show HN: Crewship – Deploy AI agents to production in one command

author: vhalasi


value:
Describe your product, drop a repo link, and the agent reads your actual code and builds multi-scene videos with animations, ElevenLabs voiceover, and branded scenes. Live editor lets you chat with the agent to tweak scenes in real time.
Stack: Next.js, Remotion (in-browser rendering), Convex (real-time state).
GitHub: https://github.com/ostepan8/subconscious-remotion-demo
Demo: https://subconscious-remotion-demo.vercel.app/

value: Show HN: Open-source agentic video editor for dev tools and side projects


value: hirokiyn

value:
Hi HN,
AI outputs keep getting better, yet I kept losing the process that produced a good result. A great session can yield a plan, a draft, a decision, even a prototype. A week later, I can’t reconstruct the exact steps, tools, checks, and judgment calls that made it work.
Most “workflow sharing” online still collapses into prompt sharing. Prompts copy well, but they rarely carry:
- human judgment calls and handoffs
- tool hookups and intermediate artifacts
- quality gates and constraints that prevent confident wrongness
I built Epismo Skills to make workflows the unit of reuse. A “skill” packages an explicit process (human vs agent steps, expected artifacts, checks), and stays runnable via MCP so it can plug into the agent environment you already use.
What this enables for the community:
- Share best practices as executable workflows: inspect, fork, adapt, and publish improved variants back
- Import and adapt a workflow to a new project instead of reinventing it from scratch
- Turn existing knowledge (project context or an external doc/link) into a reusable workflow, then publish it
Repo (MIT): https://github.com/epismoai/skills
Deeper write-up: https://hiroki.blog/posts/everything-your-agent-needs-to-run...
What workflow would you want in a community library that you could import and run today?

value: Show HN: Skills to share and reuse workflows with the community (open source)

author: hirokiyn


value: minchenlee

value:
I was running Claude Code across 10+ terminal tabs and constantly switching between them to check which session needed permission, which was done, which was idle. Tried existing tools but they required launching sessions from within their app — I wanted to keep using my own terminals.
c9watch scans running processes at the OS level and reads from `~/.claude/` to detect every active Claude Code session automatically. Works with any terminal or IDE — VS Code, Zed, iTerm2, tmux, Ghostty — no plugins or workflow changes needed.
The tray popover gives you a quick overview. The full dashboard lets you:
- Group sessions by status or by project (with git branch info)
- Expand any session to read the full conversation — formatted markdown, code blocks, tool calls
- Stop sessions, rename them, or jump to the parent terminal/IDE
- Get native macOS notifications when sessions need attention
- Use a WebSocket-based web/mobile client via QR code
Built with Tauri (Rust + Svelte), not Electron. Rust handles process scanning and JSONL parsing. The binary is small and memory usage is minimal.
MIT license, no telemetry.
GitHub: https://github.com/minchenlee/c9watch

value: Show HN: C9watch – macOS menu bar app to monitor all Claude Code sessions

author: minchenlee


value: mnemoxai

value:
I kept wasting hours building things that already existed. Asked Claude to help me build a food delivery app — searched GitHub afterward, found 847 similar repos with 12 competitors over 1k stars. 6 hours wasted.
So I built an MCP server that does the searching before you write code. It scans 5 real-time sources (GitHub, Hacker News, npm, PyPI, Product Hunt) and returns a quantified reality_signal (0-100) with actual evidence — repo counts, star counts, top competitors, and pivot suggestions.
Example: "AI code review tool" → reality_signal: 90, 847 repos, top competitor reviewdog (9,094 stars), 254 HN mentions.
What it's NOT: not a business plan generator, not an LLM opinion wrapper. Every number comes from a real API call you can verify.
- Quick mode: GitHub + HN (default)
- Deep mode: all 5 sources in parallel
- Works with Claude Desktop, Cursor, Claude Code
- One-line install: uvx idea-reality-mcp
- Also available as web demo (no install needed)
GitHub: https://github.com/mnemox-ai/idea-reality-mcp
Web demo: https://mnemox.ai/check
MCP Registry: io.github.mnemox-ai/idea-reality-mcp
Built with Python + FastMCP, 120 tests, published on PyPI. Happy to answer any questions about the scoring algorithm or MCP integration.

value: Show HN: Idea-reality-MCP – MCP server that searches real data before you build

author: mnemoxai


value:
Built this as a side project ahead of Bulgaria joining the eurozone (Jan 1, 2026).
A few things I tried that seemed to work:
- Launched ~2 months before the fixed rate announcement so Google had time to index
- The domain "levaevro.com" is a transliteration of "лева в евро" (leva in euro) – exact-match
  domains still work surprisingly well in smaller language markets
- Instead of canonicalizing all query param URLs to the homepage, I submitted 52 parameterized
  URLs to a custom sitemap (?amount=100&from=BGN, ?amount=500&from=BGN, etc.) – each one targets
  a specific search query like "100 лева в евро". Zero extra dev work, same template.
- Added a llms-sitemap.xml for AI crawlers (ChatGPT, Perplexity) alongside the standard sitemap
The fixed exchange rate (1 EUR = 1.95583 BGN) is set by EU Council regulation and will never
change, so the tool stays accurate forever with no maintenance.
Happy to share more details about the SEO approach or the technical setup.

value: Show HN: BGN/EUR converter for Bulgaria's euro adoption


value:
I had 30+ newsletters across gmail and outlook and was missing most of them. They'd get buried under promotions, spam, whatever. Tried filters, labels, separate folders. Always fell apart after a week.
The key insight: the problem isn't the newsletters, its the inbox. Newsletters shouldn't live in your email at all.
So I built Nibbl. You get a free @nibbll.app email address and subscribe to newsletters with that. They land in the app, not your inbox. You can add RSS feeds too so everything lives in one place.
Articles show up as cards you swipe through. Right to save, left to skip. My partner started calling it "tinder for articles" and honestly thats exactly what it is. Gets through a morning's worth of reading in like 5 minutes instead of 30.
Also added AI summaries (Gemini) for when you just want the key points without reading the full thing. One tap, done.

value: Show HN: Nibbl – I moved 30 newsletters out of my inbox into one swipeable feed


value: joonjung

value:
I think Suno opened up music. Kling and Runway opened up video - but there's one creative domain nobody has touched yet: dance.
So my team built an web app — give it a YouTube link to your music and it generates a 3D dance animation in under 2 minutes. The core is a diffusion-based music-to-motion model (mvnt-m4) trained on proprietary mocap/label data from professional choreographers.
I think dance is the missing piece of AI-generated content — just like how performance made K-pop a global phenomenon, and we believe AI dance will play the same role in the AI UGC era.
This is v0.1 — a fast, experimental playground. Dance quality is still improving (m4.1 in progress), and we're working on faster inference, and finger/facial motion generation. We're also preparing API integrations with platforms like Higgsfield.
I think our tech is quite validated through Epic MegaGrant but still very early in finding user validation. Would love honest feedback on the output quality and what you'd want to see next.
Also in product hunt: https://www.producthunt.com/products/mvntstudio
Demo vid:
https://youtu.be/mjq2iAr96iM

value: Show HN: mvntSTUDIO – AI model that generates dance choreography from music

author: joonjung


value: xavdeboisredon

value: Show HN: AI video editor for real estate

author: xavdeboisredon


value: stagas

value: Show HN: loopmaster 3 is out! – Code Music

author: stagas


value: bvarghese

value: Connects to your email, bank accounts, investments, health data, home cameras, and car. Storage and inference is on-device. App connects to HW peer-to-peer.

value: Show HN: Personal AI with Dedicated Hardware and App. Everything Runs Locally

author: bvarghese


value: reshevyas

value: Show HN: Open-source proxy to track Claude API costs by team

author: reshevyas


value: asmhacker

value:
Session auth says "agent can use Stripe." It doesn't say "Alice approved this $50 refund at 10:03am."
AgentMint signs short-lived tokens proving a human approved a specific action.
Ed25519 signatures
Single-use (JTI tracking)
60s TTL default
3ms verify
Full audit trail
Built in Rust. Drop-in sidecar for your backend.
https://github.com/aniketh-maddipati/agentmint

value: Show HN: AgentMint – Cryptographic proof of human approval for AI agent actions

author: asmhacker


value: amplifyco

value:
Hi HN, I built BotBrowser because I was tired of watching AI agents burn through tokens or context on raw HTML — scripts, ads, nav bars, cookie banners — just to read an article or docs.
BotBrowser gives your agent clean Markdown from any web page. A typical 50K token page comes back as ~3K tokens with all the useful content preserved.
It works as an MCP server — add one line to your Claude Desktop or Cursor config and your agent can browse the web, search and extract multiple pages, render JavaScript-heavy sites, and even take screenshots.
We're live at https://thebotbrowser.com — free tier, no credit card required.
Happy to answer any questions.

value: Show HN: Bot Browser – MCP server, saves 90% of tokens for web-browsing agents

author: amplifyco


value: jimminyx

value:
Small codebases were always a good thing. With coding agents, there's now a huge advantage to having a codebase small enough that an agent can hold the full thing in context.
Repo Tokens is a GitHub Action that counts your codebase's size in tokens (using tiktoken) and updates a badge in your README. The badge color reflects what percentage of an LLM's context window the codebase fills: green for under 30%, yellow for 50-70%, red for 70%+. Context window size is configurable and defaults to 200k (size of Claude models).
It's a composite action. Installs tiktoken, runs ~60 lines of inline Python, takes about 10 seconds. The action updates the README but doesn't commit, so your workflow controls the git strategy.
The idea is to make token size a visible metric, like bundle size badges for JS libraries. Hopefully a small nudge to keep codebases lean and agent-friendly.
GitHub: https://github.com/qwibitai/nanoclaw/tree/main/repo-tokens

value: Show HN: Badge that shows how well your codebase fits in an LLM's context window

author: jimminyx


value: Beefin

value: Show HN: Offline-First Agent Multiplexer

author: Beefin


value: obobobo

value: Show HN: ClawDocx – We built a skill and guide library for OpenClaw AI agents

author: obobobo


value: Show HN: Gas Town Control Plane – hosted monitoring for multi‑agent workspaces


value: zihao-liu-qs

value: Show HN: Treekei – understand project code structure in seconds

author: zihao-liu-qs


value: WadeToEarth

value:
I have been using Claude Code lately, and I hated seeing my daily/weekly API quotas go to waste during downtime. So I built ALBA, a system designed to turn that idle power into digital assets.
How it works:
ALBA is an autonomous software factory that runs through Claude Code. You join as a worker node, and the system orchestrates Claude Code to build, test, and deploy functional micro-MVPs like tools, landing pages, and small SaaS.
The Credit and Auction Model:
Contribute: Run a command through Claude Code to power an AI agent task.
Earn: You receive ALBA Credits proportional to the tokens and compute you provided.
Bid: Use those credits in our Auction House to bid on unique software built by the collective.
To make the discovery process more intuitive, I added an "Explore" feature that works like a vertical feed (similar to Shorts). You can quickly cycle through live demos of everything the factory has produced so far. It helps users visualize the "Asset" they are about to bid on.
Exclusive Ownership:
This is the "burn" logic I am most excited about: if you win an auction, you get the source code, and the demo environment is hard-deleted from our servers forever. You own a unique piece of software with zero duplicates.
Tech Stack:
- Frontend: Next.js (Vercel)
- Backend: Java Spring Boot (GCP Cloud Run)
- Database: Supabase/Firestore
Agent Orchestration: via Claude Code CLI
I would love to hear your thoughts on this "Token-to-Asset" arbitrage and the viability of credit-based auctions for exclusive code.

value: Show HN: Alba – Earn and bid on unique software using idle AI credits

author: WadeToEarth


value: Show HN: Can you hack my agent, but in real-time with friends?


value: eibrahim

value:
Pitch An App (https://www.pitchanapp.com) is a platform where users submit app ideas, the community votes on them, and ideas that hit the vote threshold get built.
Submitters earn revenue share when their app generates income. Voters get 50% off forever.
9 apps have been built through the platform so far.
The core assumption: non-technical people have good software ideas but no way to act on them. Community voting serves as demand validation before any development starts.
Honest limitations: the vote threshold model means only popular ideas get built, so niche-but-valuable ideas might not make the cut. Working on ways to address that.
Happy to answer questions about the model or the tech.

value: Show HN: Pitch An App – Crowdsourced app ideas with voting and revenue sharing

author: eibrahim


value: jaads

value: Helps to understand the structure of a codebase. More about it here: https://tangleguard.com/

value: Show HN: Code Architecture Visualization

author: jaads


value: wonderfuly

value: Show HN: Browser extension that takes you to the HN discussion for current page

author: wonderfuly


value: raunplaymore

value: Show HN: Pmpt-CLI – from one-off AI prompts to reproducible decision logs

author: raunplaymore


value: faalbane

value: Returns real-time and verified email addresses and phone numbers of businesses anywhere.<p>How it works: autoexpanding queries on Google Maps businesses and associated websites (email enrichment).

value: Show HN: Let your OpenClaw find you clients

author: faalbane


value: Citatra

value: The AI visibility space is repeating the worst patterns of traditional SEO tooling with high monthly pricing, closed platforms, opaque usage models, and long term lock in. So I built an open source AI visibility tool that shows when Google AI Overviews mention (planning to add more LLMs) your brand, monitors competitors, finds content gaps and audits your sites machine-readability. No paywall, no lock-in, and you get all the features of expensive AI visibility tools. Worth checking out before you spend on anything.

value: Show HN: Citatra – Opensource AI visibility tracker for Google AI Overview

author: Citatra


value: mcone

value:
I’m the author of The Markdown Guide and I built JotBird: the simplest way to publish Markdown to a shareable URL.
Paste or write Markdown, hit publish, get a link. No account required. That’s it.
Think Imgur but for markdown. Instead of dragging an image and getting a URL, you paste markdown and get a noindex web page.
It works from the web app, an Obsidian plugin, a CLI (`jotbird publish README.md`), and an API. Links last 30 days or 90 days with a free account, Pro ($29/year) makes them permanent.

value: Show HN: I Built Imgur for Markdown

author: mcone

title: Show HN: I Built Imgur for Markdown


value: murzynalbinos

value:
I built csv.repair a free, open source browser-based tool for analyzing, querying, and repairing broken or oversized CSV files. No file uploads - everything runs locally in your browser. Your data never leaves your machine.
What it does:
- Handles CSV files with millions of rows (virtual scrolling + Web Workers)
- Inline cell editing (double-click to edit, Tab to move between cells)
- Run SQL queries directly on your data (powered by AlaSQL)
- Auto-repair: trim whitespace, remove empty/duplicate rows, standardize dates, fix encoding
- Health diagnostics that flag malformed rows, inconsistent columns, encoding problems
- Column statistics and distribution charts
- Undo/redo, search & replace, keyboard shortcuts
- Export the cleaned file when you're done
- Tech stack: React + TypeScript + Vite + PapaParse + AlaSQL + Recharts + Tailwind CSS. Installable as a PWA.
Live: https://csv.repair
I'd love feedback especially from people who regularly deal with messy CSV files.

value: Show HN: Csv.repair – Free browser-based tool to fix broken CSV files

author: murzynalbinos


value: TIPSIO

value:
This was my personal agent setup that I am now open-sourcing. The landing page got a little crazy. I am a big fan of Claude Code.
There are many alternatives such as OpenClaw, now an official Claude Code Remote Control, and a bunch of open source mini claw projects.
This is different because it:
- Create/Manage/Access Claude Code "Terminals" sessions remotely
- Is basically just contained to a skill and small setup
It also has really cool features from experimenting:
- "Parties" which is a fun way to have your Claude Code sessions coordinate (swarms you can control)
- On-Demand TUI display engine
- Easy automatic skill builder (OAuth & webhook helper)
- Message from Telegram/Slack directly to Claude Code terminal
- Chores (AI assigns to you, you don't assign to it
Then all the classics:
- heartbeat
- memory
- background manager / helpers
- others
And then most importantly:
- It will add a little ASCII dog to your terminal

value: Show HN: Clappie – Claude Code remote but more fun and useful

author: TIPSIO


value: jazzen

value: Show HN: I built a multi-model AI terminal with a custom mobile web UI

author: jazzen


value: wanderinglight

value: Show HN: Fast Database for Agents

author: wanderinglight

title: Show HN: Fast Database for Agents


value:
I revived a small project I abandoned ~5 years ago and just released v0.2 on PyPI: validatedata.
It's a lightweight Python library for inline data validation—think quick checks on dicts, lists, function args, or API payloads without defining full schema classes like in Pydantic.
Why revive it? I kept running into cases where Pydantic (or Marshmallow) felt like overkill for scripts, CLIs, simple backends, or one-off data cleaning. I wanted something expressive but minimal: inline rules, decorators, no boilerplate models, built-in checks (email/url/phone/regex/range/length/unique/nullable/transforms/conditionals/nested), and clean error output.
Core ways to use it:
1. Standalone on data:
```python
from validatedata import validate_data
data = {"username": "alice", "email": "alice@example.com", "age": 25}
rules = {"keys": {
    "username": {"type": "str", "range": (3, 32)},
    "email": {"type": "email"},
    "age": {"type": "int", "range": (18, "any")}
}}
result = validate_data(data, rules)
if result.ok:
    print("Valid!")
else:
    print(result.errors)  # e.g. ["age: must be at least 18"]
Features include:
Shorthand rules like 'email', 'int:18:to:99', 'phone'
Conditional (depends_on), transforms (strip/upper), mutation for cleaned data
Nested fields/items, strict/no-coercion mode
Powered by dateutil for flexible date parsing (ISO, natural-ish formats)
MIT licensed, pytest on PRs, Python >=3.7, only optional dep (phonenumbers for phone)
Install: pip install validatedata
Repo: https://github.com/Edward-K1/validatedata
PyPI: https://pypi.org/project/validatedata/
Happy to hear feedback, bug reports, feature ideas, or use-case stories—especially if this saves anyone time on lightweight validation. Does this fill a gap for you, or am I missing something obvious?
Thanks!

value: Show HN: Validatedata – lightweight inline data validation for Python


value: DavidCanHelp

value: Show HN: FOSS Slack Archive Viewer and Exporter

author: DavidCanHelp


value:
So we're a startup building a wearable device, and our PCBs kept failing due to the tiniest design errors. Every iteration cost us weeks of time and thousands in costs and lost revenue.
That's why we built CheckMyPCB, a PCB verification tool, and now finally have a working PCB. Just upload your netlist and schematic PDF, and let it run a deep analysis that checks whether your circuit is designed correctly against the datasheets of hundreds of components. It even caught design errors that even senior engineers missed.
Based on feedback from early users, we also added a component sourcing tool, so no more searching across 10 different vendors to find a single component, or last-minute lead-time and EOL headaches.
Currently in beta and free to use.

value: Show HN: Our PCB kept failing, so we built a PCB verification tool


value: juanghiri

value: Show HN: ForgeCraft, MCP that generates standards for spec-driven coding

author: juanghiri


value: everythingabili

value: Show HN: HyperCOD – a web-based HyperCard-clone

author: everythingabili


value:
Claude Code deleted my research and plan markdown files and informed me: “I accidentally rm -rf'd real directories in my Obsidian vault through a symlink it didn't realize was there: I made a mistake. “
Unfortunately the backup of my documentation accidentally hadn’t run for a month. So I built claude-file-recovery, a CLI-tool and TUI that is able to extract your files from your ~/.claude session history and thankfully I was able to recover my files. It's able to extract any file that Claude Code ever read, edited or wrote. I hope you will never need it, but you can find it on my GitHub and pip. Note: It can recover an earlier version of a file at a certain point in time.
pip install claude-file-recovery

value: Show HN: Claude-File-Recovery, recover files from your ~/.claude sessions


value: alfredoizjr

value: Show HN: ContextForge – Persistent memory MCP server for Claude

author: alfredoizjr


value: motsarnt

value:
I wanted to compare star growth between a few repos and couldn't find a tool that did it the way I wanted, so I built one.
Most existing tools have a backend that proxies requests to the GitHub API, which means your token goes through someone else's server. They also don't cache results, so if you look up the same repo twice you're burning rate limit both times. And they're mostly single-metric viewers.
This tool is entirely client-side. Your GitHub token goes directly from your browser to the GitHub API, no backend.
Results are cached in the browser so repeat lookups are instant You can search for repos by name or paste a URL, add multiple repos, and compare their star history and contributions overlaid on the same chart.
You don't need an account to use it. If you have a GitHub token you can use that to raise your rate limit,it's optional but highly recommended for basic use.

value: Show HN: I built a client-side GitHub repo comparator

author: motsarnt


value: kacy

value: Show HN: Ember – A modern Redis drop-in replacement built in Rust

author: kacy


value: tranhoangtu

value: Show HN: Mcpman – The package manager for MCP servers

author: tranhoangtu


value: imprakharshukla

value:
Hey HN,
I'm a solo dev and I kept wasting hours hand-writing CSS
@keyframes to animate SVGs. Write a keyframe, preview, tweak
the timing, preview again, repeat. For anything beyond a
simple fade it turns into dozens of rules across multiple
elements. I wanted something where I could just describe the
motion and get working animations back.
SVG Weave is a visual node graph editor for this. You place
nodes on a canvas (SVG input, prompt, render) and connect them
with wires. Type what you want the animation to do, hit
render, and the AI streams CSS @keyframes back in real time.
You see the SVG come alive as tokens arrive.
Things that might be interesting technically:
- Style-inject mode: when only animations are needed, the AI
outputs just a <style> block instead of rewriting the full
SVG. Faster and avoids corrupting path data.
- Overlap detection: the system prompt makes the model analyze
element layering and restrict partially-covered elements to
opacity/scale only, preventing hidden edges from being
revealed during translation.
- State transitions: connect two SVGs (start and end) and AI
generates a single animated SVG that morphs between them using
CSS transforms, opacity, and clip-path.
- Chaining: output of one render feeds as input to the next
prompt, so you can build complex animations step by step.
- Shadow DOM isolation in the preview modal so SVG styles
don't leak into the host page.
You can also generate SVGs from text descriptions or vectorize
raster images in the editor.
Stack: Next.js, React Flow, Convex, Gemini via OpenRouter.
Free signup gets you 20 credits (one render costs about 10).
Requires an account to save projects but you can see the full
editor immediately.
svgweave.com

value: Show HN: SVG Weave. A node graph editor that animates SVGs with AI

author: imprakharshukla


value: metriclogic

value:
Built this after learning 87% of pre-2010 games are no longer legally available.
Tracks 307 games across 42 franchises showing:
- Which are delisted (MGS4, GTA trilogy, Halo 3, etc.)
- Release vs chronological order
- CIB complexity for physical collectors
- Real-time eBay links
Just launched today. Built with Next.js + Supabase. Feedback welcome.

value: Show HN: Gameorder.gg – Track which retro games are being delisted

author: metriclogic


value: martialg

value:
Think Notepad, but with goats!
It started as a joke with some friends and then I realized this was the perfect project to see far I could get with Claude without opening my IDE (which I'd wanted to try for a while with a small app)
I was pretty shocked to find that I only needed to manually intervene for:
1. Initializing the repo
2. Generating sprites - I tried a few image gen tools, but couldn't get a non-messy looking sprite to generate to my liking. I ended up using some free goat sprites I found instead (credited in the About section)
3. Uploading images/sprite sheets (raw claude code can't do this for some reason?)
4. DNS stuff
Aside from agents timing out/hanging periodically and some style hand holding, it was pretty straightforward and consistently accurate natural language coding end to end. I suspect this is in large part to replicating an existing, well documented style of app, but it was good practice for other projects I have planned.
The goats slowly (or quickly if you change modes) eat your note and if they consume more than half of it, you lose the file forever. I did this as an exercise to practice some gamelike visuals I've wanted to implement, but was surprised to find that this is actually a perfect forcing function to help me stay focused on text editor style tasks.
I tend to get distracted mid-stream and the risk of losing the file when I tab away has mitigated more than I expected.
Enjoy!

value: Show HN: Goatpad

author: martialg

title: Show HN: Goatpad


value: Thunderstomp

value:
I'm a former chef with no CS degree, running 3 AI agents (PM, Builder, Auditor) building a D&D 3.5e combat engine. Every pattern in this repo was born from a specific failure.
The failure catalog is the real value. Examples:
- "Ghost Target" (pattern #3): Agent confidently "fixed" a bug that didn't exist. Now we verify gaps before writing code.
- "Write-Only Field" (pattern #8): Agent wrote data at character creation that nothing ever read at runtime. 17 fields exposed. Now every data write requires a consume-site proof chain.
- "Parallel Drift" (pattern #9): Two code paths computing the same attack logic diverged by 21 modifiers. Now every resolver change requires parity verification across all paths.
- "Coverage Theater" (pattern #12): 30+ rows in the coverage map went stale. Tests passed but tracked nothing. Now coverage updates are mandatory in every debrief.
- "Governance Consumption Failure" (pattern #15): PM wrote rules. Nobody read them. Process docs had no enforcement mechanism. Now methodology lives in auto-loaded config, not optional docs.
21 patterns total, each with: the failure that created it, the rule that prevents it, and a real example from production.
Not a framework you install — it's a methodology repo. The patterns are language/tool agnostic.
Happy to answer questions about what it's like building real software with multi-agent coordination when you're not a developer.

value: Show HN: Patterns for coordinating AI agents on real software projects

author: Thunderstomp


value: brhkim

value: Show HN: DAAF – Reproducible AI-assisted data analysis for researchers

author: brhkim


value: burrnii

value:
Hi HN,
I’m the creator of SynapsCAD, an open-source desktop application I've been building that combines an OpenSCAD code editor, a real-time 3D viewport, and an AI assistant.
You can write OpenSCAD code, compile it directly to a 3D mesh, and use an LLM (OpenAI, Claude, Gemini, ...) to modify the code through natural language.
Demo video: https://www.youtube.com/watch?v=cN8a5UozS5Q
A bit about the architecture:
- It’s built entirely in Rust.
- The UI and 3D viewport are powered by Bevy 0.15 and egui.
- It uses a pure-Rust compilation pipeline (openscad-rs for parsing and csgrs for constructive solid geometry rendering) so there are no external tools or WASM required.
- Async AI network calls are handled by Tokio in the background to keep the Bevy render loop smooth.
Disclaimer: This is a very early prototype. The OpenSCAD parser/compiler doesn't support everything perfectly yet, so you will definitely hit some rough edges if you throw complex scripts at it.
I mostly just want to get this into the hands of people who tinker with CAD or Rust.
I'd be super happy for any feedback, architectural critiques, or bug reports—especially if you can drop specific OpenSCAD snippets that break the compiler in the GitHub issues!
GitHub (Downloads for Win/Mac/Linux): https://github.com/ierror/synaps-cad
Happy to answer any questions about the tech stack or the roadmap!

value: Show HN: Vibe Code your 3D Models

author: burrnii

title: Show HN: Vibe Code your 3D Models


value: kenryu

value: Show HN: A CLI tool for agentic code review and auto-fixing

author: kenryu


value: aadivar

value:
Hi HN! I am Dan (aadivar), one of two people who have built Kite, a tool with a simple goal: get rid of brain rot and internet addiction.
Modern websites are built to keep you engaged using algorithmic feeds, infinite scroll, social proof counters, autoplay recommendations, urgency timers, etc. Even when you intend to check one thing, you get pulled into a 45-minute session you didn't choose.
I personally noticed this with my daughter, who was getting pulled into YouTube Shorts rabbit hole addiction, while she was supposed to be using the platform for science and music lessons. Trying to limit her time on the app didn't help much, and blocking YouTube entirely would block the educational content as well.
I wanted a way to block only YouTube Shorts while keeping the other longform video content. Unfortunately, a simple solution for my problem did not exist. Thus the idea for Kite was born.
With Kite, anyone can use natural language to say:
- "Hide shorts"
- "Replace infinite scroll with pagination"
- "Hide like counts"
And the tool does exactly what you need, thus removing brainrot rabbit holes and other addictive elements.
**
Kite is available under a closed beta right now, and we would especially love feedback from folks who spend a lot of time on YouTube, Twitter/X, Reddit, LinkedIn, or shopping platforms.
Beta sign-up here: https://www.agentkite.com
Happy to answer any technical questions about how the agent safely modifies websites on the client side.
**
BTW, We also built AttentionGuard, which detects manipulation patterns like FOMO cues, engagement traps, social pressure signals etc. in real-time and flags them. This extension is open-source (MIT license) and live for Chrome and Firefox now. More details on our website!

value: Show HN: Brainrot messed up my kid's attention span, so I built a tool to fix it

author: aadivar


value: thomasfromcdnjs

value: Show HN: Find like-minded developers from your GitHub activity

author: thomasfromcdnjs


value: wolfejam

value:
I use Claude, Codex, Cursor, and Gemini on different projects. Each one has its' own md file in its own format. CLAUDE.md, AGENTS.md, .cursorrules, GEMINI.md.
   Four files saying roughly the same thing, four chances to get out of sync!

  I kept forgetting to update one, then wondering why Cursor was hallucinating my project structure while Claude had it right.

  So I built an MCP server that reads a single YAML file (project.faf) and generates all
   four formats. 7 bundled parsers handle the differences between them. You edit one file, and bi-sync keeps everything current.

  It's an MCP server, so Claude Desktop can use it directly. 61 tools, 351 tests, no CLI dependency.

  Try it: npx claude-faf-mcp

  Source: https://github.com/Wolfe-Jam/claude-faf-mcp

  The .faf format itself is IANA-registered (application/vnd.faf+yaml).

  Curious if others are dealing with this multi-AI config problem, or if there's a simpler approach I'm not seeing.

value: Show HN: I got tired of syncing Claude/Gemini/AGENTS.md and .cursorrules

author: wolfejam


value: TylerArrows

value: Show HN: SignalCend – API that resolves conflicting IoT device state in 47ms

author: TylerArrows


value: madamdo

value:
My 10-year-old son has been deep in low-level rabbit holes lately and ended up vibe-coding his own operating system. Since he’s still a kid and not on HN himself, I’m posting this on his behalf with his permission.
This started as curiosity about how computers actually boot, and somehow escalated into writing a kernel, building a GUI, and setting up CI that produces a bootable OS image on every commit.
BananaOS is a small experimental operating system built mainly for learning and exploration of low-level systems programming. It currently targets i386 BIOS systems and is designed to run on extremely constrained hardware. Fun fact: Wallpaper logic, one of the most important OS functionalities, is directly implemented in the kernel. That cracked my son up!
Some highlights:
Multiboot-compliant kernel loaded via GRUB
VESA framebuffer graphics with double buffering
Custom window manager with movable and resizable windows
Dock-style application launcher
PS/2 keyboard and mouse input handling
PCI enumeration and AHCI SATA support
Basic applications (terminal, notepad, calculator, file explorer, settings)
Memory detection and allocation based on available RAM
Boots in QEMU with about 11.2 MB RAM
Includes an ISR workaround to emulate CMOV so it can boot on Intel 486 CPUs
One thing I found particularly fun: he also added GitHub Actions workflows that automatically build the OS image for every commit, so the repo continuously produces fresh bootable artifacts.
The project is very much experimental and should only be run inside an Virtual Machine.
Repo (with build instructions and screenshots):
https://github.com/Banaxi-Tech/BananaOS
Quick start (only on Linux, check dependencies, and see README):
git clone https://github.com/Banaxi-Tech/BananaOS
cd BananaOS
make
qemu-system-i386 -cdrom bananaos.img -m 128M
Retro mode:
qemu-system-i386 -cpu 486 -cdrom bananaos.img -m 11.2M
He’s mainly building this to understand kernels, memory management, drivers, and how operating systems actually work below user space.
Feedback from people who have built hobby operating systems or worked close to hardware would be especially appreciated.

value: Show HN: BananaOS, vibecoded operating system that boots on a 486 with ~11MB RAM

author: madamdo


value: AdewoleJasper

value:
As a daily Claude Code and Cursor user, I kept hitting the same wall:
the agent shows me a plan as a numbered list in the terminal, then
starts coding. I can't reorder the steps. I can't monitor what's
happening at step 8 without scrolling through a wall of output. I
can't attach my Stripe API key to just the payment step without it
leaking into every other step. And I can't tell step 3 to use the
Figma MCP while step 7 uses Supabase.
Overture is an open-source MCP server that intercepts the agent's
planning phase and renders it as an interactive node graph in the
browser before execution starts.
Each step becomes a node. Dependencies become edges. You click into
a node and attach exactly what it needs: files, docs, API keys, MCP
servers, natural language instructions, all scoped to that step only.
You drag to reorder, delete what you don't need, add what's missing.
At decision points, you pick an approach or run branches in parallel
and compare the output. During execution, each node updates
individually so you see exactly where things stand.
Under the hood, agents generate plans in structured XML (<node>,
<edge>, <field> elements). Overture parses it into the graph. Agents
can also declare typed input fields per step, so if a step needs a
Stripe key or a database URL, you fill it in during planning instead
of getting interrupted mid-execution.
Works with any MCP-compatible agent. npx overture to try it.
Everything local.
Biggest open problem: getting agents to consistently produce
well-structured plans. Claude Code cooperates well. Cursor is
hit or miss. If anyone has experience with prompt engineering for
structured output from coding agents, I'd love to compare notes.
GitHub: https://github.com/SixHq/Overture.git

value: Show HN: Overture – Interactive plan graphs for AI coding agents (open source)

author: AdewoleJasper


value: mattyhogan

value: Show HN: Open-source agent with a brain instead of MEMORY.md

author: mattyhogan


value:
Hey HN,
I built a PDF reader that can generate interactive visualizations right inside the document. The goal is to reduce the “intuition gap” when reading dense papers: select a concept, click Visualize, and it tries to produce a solid visual interactive app where you can rotate/zoom/step through (not just a text explanation).
Upload any PDF, select text, click Visualize.
Demo (no signup):  https://zerodistract.com/try/pdf/67cdee74-810b-4f1b-af7d-010...
Product link: https://zerodistract.com
I’d love feedback, especially on what feels useful vs. distracting, and where it breaks.

value: Show HN: PDF reader with interactive visualizations for research papers


value: anticlickwise

value:
I’ve walked out of meetings feeling uneasy more times than I can count.
Nothing dramatic happened.
No arguments.
No pushback.
Everyone agreed. We moved on. But later, in a one on one or a Slack message, someone would say, “Yeah… I wasn’t totally comfortable with that either.”
And that’s the part that stuck with me. How often are we all thinking the same thing… and just waiting for someone else to say it first?
That question is why I built The Elephant. It’s very simple.
Everyone anonymously writes one sentence: What do you think we’re not saying out loud?
If more than one person independently mentions the same concern, it shows up. If you’re the only one thinking it, it stays private.
No votes. No threads. No exposing who said what.
If nothing appears, nothing appears. It’s small on purpose. It’s not trying to fix conflict or replace real conversations. It just creates a safer way to see if the concern you’re holding… is shared. I’m honestly curious, does this feel useful? Or is this overthinking something that should just be said directly?
Would love your thoughts.

value: Show HN: The Elephant- a Tool to Safely Surface the Unspoken Issue in Meetings

author: anticlickwise


value: dilawargopang

value: Show HN: RedTeam Arena – AI vs. AI adversarial security testing in your terminal

author: dilawargopang


value: alexandriaeden

value:
https://cbrowser.ai
Most browser automation asks "did the button work?" CBrowser asks "will a real person find the button?"
It's an MCP server (83 tools) that connects to Claude and gives it a real browser. But the core idea is cognitive journey simulation — you pick a persona (first-timer, elderly user, power user, someone with ADHD, low vision, motor tremors) and CBrowser walks your site the way they would. Each persona has 25 cognitive traits (patience, risk tolerance, comprehension, working memory) that determine how they react to friction. When frustration or confusion crosses a threshold, they abandon — just like a real user.
Each persona also has a motivational values profile based on Schwartz's 10 Universal Values (security, achievement, self-direction, benevolence, etc.) plus Self-Determination Theory needs and Maslow levels. These aren't decorative — they drive which influence patterns each persona is susceptible to. A security-motivated user responds differently to urgency cues than an achievement-motivated one. You can test whether your site's persuasion patterns actually work on your target audience, or only on people who already think like your designers.
What it actually does:
cognitive_journey_init + browser tools = watch a simulated persona attempt a task on your live site
compare_personas = same task, multiple personas, side-by-side friction analysis
competitive_benchmark = run the same journey on your site and a competitor's
empathy_audit = test with disability personas (WCAG violations + lived-experience barriers)
Plus the usual browser automation: navigate, click, fill, screenshot, cross-browser testing, visual regression, performance baselines
The self-healing selectors cache alternatives (aria-label, role, ID, text) at match time and fall back through them ranked by confidence, with a 60% gate so you don't get silent false passes.
TypeScript, MIT, connects to Claude.ai via the demo MCP server or install locally with npm. Built on Playwright.
I'd love feedback on the persona model — are 25 cognitive traits + 10 motivational values too many? Too few? Are the abandonment thresholds realistic?

value: Show HN: CBrowser – Simulate how a confused first-timer experiences your website

author: alexandriaeden


value: shreyvj

value:
I built Inkgest over the past few months as a solo developer.
The core idea: paste any URL, Inkgest scrapes the content using my own scraping API (not Firecrawl, no third-party, custom scraping API), sends it through
an LLM, and generates publish-ready content in whatever format you need — newsletter, blog post, infographic, tables, LinkedIn post, or deep comparison table.
A few things I built that I found interesting technically:
- Wrote my own scraping backend in Hono.js instead of using a third-party service. Runs as a persistent server, so no cold starts. Handles JS-rendered pages.
- The infographic renderer generates real SVG/React
  components from extracted data — doughnut charts, step flows, stat cards, comparison splits. No image generation APIs, all rendered code.
- Built on top of my own SaaS boilerplate (buildsaas.dev), which handles auth, payments, email, and admin out of
  the box.
Launched yesterday. 3 free credits to try everything,
$9/month after that.
Happy to share the product and discuss in depth about the AI agent, scraping techniques, and building SaaS products.
inkgest.com

value: Show HN: Inkgest, Link to Gest

author: shreyvj

title: Show HN: Inkgest, Link to Gest


value: xlii

value:
I built DiagramIDE because I wanted a more modular way to handle diagramming-as-code. It’s a Rust-based GUI (EGUI) where you can split logic, data, and rendering into separate windows. Instead of one giant DSL file, you can script components in Tcl, define relationships in Prolog, and pipe the results into Pikchr for the final render.
Fair warning: it’s an early alpha and still quite rough around the edges. I’ve been dogfooding it for my own work so it’s definitely functional but expect unexpected.
Shortest way to try it out is a compiled binary release: https://github.com/exlee/pikchr.pl/releases/tag/latest

value: Show HN: DiagramIDE – a Rust GUI to Compose Diagrams via Tcl, Prolog, and Pikchr

author: xlii


value: indranilbhuin

value:
Over the past year I built zero, a fully offline expense tracker for Android and iOS.
Most finance apps today rely on accounts, cloud sync, subscriptions, and analytics. I wanted to try the opposite approach:
No accounts
No cloud storage
No telemetry
No ads
No subscriptions
All data stays locally on your device. The project is open source and focused purely on privacy and simplicity.
Would love feedback on:
• Offline-first product viability
• Non-SaaS monetization models
• UX tradeoffs when you remove analytics
Happy to answer any technical questions.

value: Show HN: Zero – offline, privacy-first expense tracker

author: indranilbhuin


value:
It’s still a work in progress, so I’m sharing early for feedback.
What I think is different from most tools: it has a Quick mode for speed and an Advanced mode for full control, so you can either generate fast or fine-tune details (canvas, layers, frame, screenshot, background) in one place. It’s guided but not rigid, and preview/export are built to stay aligned so output matches what you see while editing.
It works great on mobile as well where other apps struggle.
No signup needed (might add pro features in future)
No ads
If you test it, I’d really value feedback on time-to-first-export, export quality consistency, and what’s missing for you to switch from your current tool.

value: Show HN: SnapMyApp – App Store screenshot maker with Quick and Advanced editing


value: stevekemp

value: Show HN: Org-people.el- contact management for org-mode

author: stevekemp


value: sdrshnptl

value:
Hi HN!
I’m sharing a simple but useful VS Code extension I built:
https://github.com/sdrshnptl/notifybuildresult
It broadcasts UDP messages whenever VS Code tasks complete (success or failure), so you can easily trigger external hardware or systems — like RGB LEDs, displays, IoT devices, dashboards, or automation workflows — based on build status.
Key features:
- Sends UDP broadcasts when tasks finish
- Works with custom task filters and message templates
- Offers status bar feedback and a history of broadcasts
- Includes Python/Node/ESP32 examples for receivers
- Configurable broadcast address and port (default 10203)
Use cases:
- Physical build-status lights
- Office / home IoT indicators
- Custom dashboards or CI signals
- Robotics or lab integrations
I’d love feedback on additional protocols (MQTT/WebSocket), security considerations, and ideas for broader dev integrations.
Thanks!
sdrshnptl

value: Show HN: VS Code tool that sends UDP on task success or failure

author: sdrshnptl


value: guvencem

value:
Every time you switch AI models mid-project, the new model starts from zero. It doesn't know your stack, your conventions, or what you were working on five minutes ago.
I built handoff-md to fix this. It's a CLI tool that analyzes your git repo and generates a single HANDOFF.md file. Paste it into any AI model and it instantly understands your project.
What it does:
- Parses git history (last 20 commits, branches, uncommitted changes)
- Detects your stack (framework, ORM, DB, auth, deploy, test runner)
- Reads naming conventions, folder structure, API patterns
- Picks up existing AI config files (CLAUDE.md, .cursorrules, AGENTS.md)
- Outputs a single markdown file, around 3000 tokens
Usage: npx handoff-md
No config, no API keys, no dependencies beyond Node.js and git. Works with Claude, GPT, Gemini, Codex, local models, anything that reads markdown.
There's an open issue in Claude Code (#11455) requesting exactly this. Cursor, Windsurf, and Copilot don't have it either. So I built it as an open source CLI that works everywhere.
Built with TypeScript. MIT licensed. Feedback welcome.

value: Show HN: Handoff-md – One command to generate portable AI context from any repo

author: guvencem


value:
Hi HN,
I built NeuroSync originally as a final year school project to explore Neural Cryptography. The main idea is the use of adversarial learning to train two NNs (Alice and Bob) to encrypt and decrypt data while a third one (Eve) is trying to break the cipher. While that isn't new I made it into a usable library with an interface that allows to easily switch parameters and experiment with them to help research in this field.
To make it functional, I implemented a hash-based correction system to ensure 100% decryption accuracy (bypassing the usual 0.2% probabilistic errors of neural synchronization), alongside packet sequencing and periodic key changes.
It is definitely still a work in progress, and the "Eve" (attacker) network currently needs a lot of work. But the first version is usable and the core communication protocol works.
I added a Jupyter Notebook in the repo so you can test the key exchange and encryption without setting anything up. I'm sharing this mostly to get your feedback, hear your ideas, and maybe find some folks interested in this field too.
Would love to hear your thoughts or critiques!

value: Show HN: NeuroSync – An experimental Python library for neural cryptography


value: vbfs

value: Show HN: AI-Native Function and Cron as a Service

author: vbfs


value:
Hi HN — I’m building Docpose.cloud (online file conversion + API). File processing is a trust problem, so I wrote a security + processing architecture page that explains exactly how files move through the system.
Highlights:
S3-only pipeline: workers read from object storage and write results back
No permanent local disk persistence on workers
Source files deleted immediately after processing
Converted files expire after 24 hours by default
Operational logs kept up to 30 days (metadata only, no file contents)
I’m posting this because security questions come up every time someone evaluates file-processing infrastructure. Feedback welcome — especially on what you’d want clarified for a vendor security review.

value: Show HN: Cloud file conversion security model (S3-only, 24h retention)


value: bluehatkeem

value: Show HN: Tubeletter – Turn YouTube videos into news articles

author: bluehatkeem


value: stevehiehn

value: Show HN: Define MCP tools as YAML specs

author: stevehiehn

title: Show HN: Define MCP tools as YAML specs


value: white

value:
Hi HN,
I use ChatGPT and Claude daily for research and coding. I often wish they had direct and fresh access to discussions in the private product, marketing, ideas, and engineering news communities I’m part of on Slack, Discord, Telegram,...
So I built c8lore.com (for "community lore" :) that connects and indexes many communities once — it indexes the discussions (near real-time) and LLMs can then semantically search them, pulling relevant threads, workarounds, and insights straight into prompts. It ships with an MCP server so you can simply tell your LLM `use c8lore`.
It’s fed with some initial sources focused on these exact topics (product, marketing, ideas, engineering, ...), and I’m actively adding more. The public directory is open for anyone to browse.
I’d love your feedback:
1. Do you participate in private or semi-private communities for product, marketing, ideas or engineering (or else) discussions? Which platforms? Discourse, Facebook Groups, ...?
2. If you’ve looked at c8lore, does bringing this knowledge into your AI workflow feel useful? What’s missing that would make researching or keeping access to this information easier?
3. Which communities or types of sources would you find most interesting?
Thanks in advance — really appreciate any thoughts or suggestions!

value: Show HN: C8lore – Discussions from Slack, Discord, Telegram Communities in LLMs

author: white


value: ronistrom

value:
Hey HN, I built Yeethook (https://www.yeethook.com/) to solve a problem that bugged me every day as an iOS developer: having no real-time visibility into what's happening in App Store Connect.
The problem: Tools like Sentry, RevenueCat, and Firebase each cover a slice, but nothing catches all Apple events in one place. And Apple's own webhook payloads are cryptic: event IDs and status codes, not the information you actually need. I wanted one service that catches everything, enriches it, and routes it to the right Slack channels.
What Yeethook does: You upload your App Store Connect API key (p8), and Yeethook:
- Receives webhooks from both App Store Connect and App Store Server Notifications V2
- Uses your p8 key to pull the full context: crash logs with stack traces, tester names, device models, OS versions, screenshots, subscription details
- Delivers formatted Slack messages to the right channels. Crashes to #bugs, review updates to #releases, subscription events to #revenue.
A TestFlight tester hits a crash, and seconds later your team's Slack channel has the crash log, the device info, and the screenshot. Before anyone opens Xcode, everyone already knows what happened.
The p8 key is optional (you can skip enrichment and configure webhooks manually), and encrypted at rest when connected. The Slack connection is one-way via incoming webhooks. Yeethook sends messages, it can't read your channels.
Setup takes a few minutes. Upload your p8 key, pick your Slack channels, and Yeethook creates the webhooks on Apple's side automatically. It also monitors webhook health on both the Apple side and the Slack side.
Beyond delivery: There's a dashboard with delivery metrics and trends, and an event log where you can inspect any event down to the raw payload, enriched data, and per-channel delivery status with retry history. One team account with shared visibility, no per-developer setup.
Pricing: Free for 1 app and 100 events/month. Paid plans start at $15/mo. Enrichment (p8) is included on every plan, including free.
Right now it's Slack only. Discord, Teams, PagerDuty, and email are next.
I'd love to hear what you think, especially from teams already dealing with App Store Connect webhooks.

value: Show HN: Yeethook, Enriched App Store Connect Webhooks to Slack

author: ronistrom


value:
My apartment is a mess. Between day work, kids and all the side projects cleaning is the thing that usually takes the back air. It’s embarrassing really, I can come up with a sophisticated tech strategy, find the right words to say to an employee who’s down and I can’t seem to fold the laundry when I take it out of the dryer. I’m a developer by heart, so after a little bit of self pity, I decided that my daughters are to blame for the mess and thus dug head deep into debugging the problem ans researching the solution. I asked my youngest why is it so hard for her to clean and she said ”Mom, I don’t see the mess”. ”Okay, then I need an app that would help you see the mess” - thought I to myself. We tried the concept in our WhatsApp group first: one would ”hunt” for ”cleaning bounties” (Hounty = home bounty), the other would clean and send an picture back as a proof. It was fun, but a bit hard to track. Great! Let’s turn it into an app, add some family coins on top and problem solved!
Well, it’s been a year since then and oh boy did I go down that rabbit hole! You know what I learned about kids? They get bored instantly. A trick what worked once won’t work again and the fun game was apparently fun only once. But I did build an app an released it on iOS, it was a fully offline version, I didn’t spend much time advertising it of at all, but I did show it to my friends. What surprised me is that me and my and a few of my very much grown up friends were using it quite often and enjoying the little ghost cheeky humour. And so I decided to focus on making the cleaning work for me and for other grown up ambitious kids.
First of all, I redesigned my Flutter app into a sleek black and flames look. It took several months of back and forth before it started to look how I wanted. Once it did I realised that my central event bus was eating up a lot of memory on the device (those web devs making apps, amiright?), but better late than never! And then I almost lost my clean pics after switching between live and test flight version, so several months and three rebuilds after (Cloudflare, no, Supabase, no, Scaleway, JS, no Go!) I finally had a working cloud sync and authentication. You know what was the easiest thing to add? Gen AI api to plan the cleaning for me. That worked right away almost and as my friend told me ”Wow! It sees everything!”. It does, it sometimes creates a 1px tall pictures, but it does see all the mess. Magic of AI!
Of course I added passkeys, token usage and subscriptions and hyper optimized the image compression. Backend is just one service though, but it’s modular waiting to be split and deployed on Kubernetes! And hey after a year and 2 weeks of app review-rejection-review-approved-ohno-review-approved it went live!
Fun fact, the app was originally paid, so when I submitted a new version for review I made it free aaand got 500 downloads for the old version because apparently there are ”apps gone free” communities that pick those things up automatically. So Hounty is clearly up for a great start already!
Jokes aside I wanted to drop it several times, it’s brutal to handle a full stack side project, I’m sure many here can relate. Luckily the pesky ghost has been reminding me of it daily from a sticker that I printed and glued on my phone. And finally, it’s done and I’d love to hear what you think: is it over engineered or should I add an MCP server to it? :)

value: Show HN: High Tech Before/After Cleaning Gallery


value: tgiordano

value:
Capital formation is still spreadsheet-driven and rebuilt from scratch every raise.
I’m building an open‑source Capital Formation Operating System designed to formalize that process into structured infrastructure.
Current scope:
• Postgres (Supabase) backend live
• Venture, Investor, Deal, and Value Ledger schema defined
• Deterministic investor matching engine (spec)
• Event-based value logging layer
• AI agent specs for matching, outreach, and meeting-to-memo
The goal is to turn fundraising from a bespoke workflow into a compounding system where:
– Ventures are standardized
– Investors are structured as a graph
– Matching is reproducible
– Every interaction generates persistent artifacts
– Outcomes improve future raises
This is infrastructure-first, not a CRM clone.
Looking for backend / systems engineers interested in data modeling, matching logic, and capital-market infrastructure.
Repo: https://github.com/agio711/Riserva-Fly

value: Show HN: Open‑Source Capital Formation OS (Postgres and AI Agents)

author: tgiordano


value: Show HN: I Built AGI on GitHub Actions

title: Show HN: I Built AGI on GitHub Actions


value: juanzab

value: Show HN: Roxlit – Open-source launcher that connects AI tools to Roblox Studio

author: juanzab


value: Show HN: Interactive Resume/CV Game

title: Show HN: Interactive Resume/CV Game


value: caffaroai

value: Show HN: NutriAssess – AI body composition for nutritionists

author: caffaroai


value: I was sick of finding out a cloud provider was down when casually doomscrolling on X in the middle of work. So I built Pingy as a fun side project, it sends me a push notification whenever a cloud provider is experiencing an outage or a degradation.<p>AWS, GCP, Azure, GitHub, Stripe, OpenAI, Supabase, Vercel, Cloudflare, and 50+ more are tracked. I just pushed it App Store yesterday and if you are paranoid like me, checkout Pingy on the App Store.

value: Show HN: My iPhone notifies me about cloud outages before they blow up here


value: strongpigeon

value:
Hey HN,
About 5 years ago, I built a weightlifting app for 5/3/1 that got me on the front page of HN [0]. After that, life happened. I had kids and so decided to get a job and put that project on ice. Eventually I grew too disappointed with my job, and decided to try building something again.
The biggest feedback I kept getting from users was simple:
“Let me create my own programs.”
That’s how Vis started.
The initial idea was to create a B2B platform where gyms and trainers could build programs using formulas (e.g., percentages of 1RM) and reusable blocks instead of spreadsheets. I built what I still think is the best workout editor out there, but I quickly found out that B2B sales is hard (or maybe I just suck at it). It also just didn’t feel like a big enough sell for gyms.
So I pivoted. I focused on the iOS app for a while [1], and now re-packaged the editor so individuals can use it directly.
With Vis Pro, you can:
- Define programs using formulas (e.g., 0.85 * SQUAT_1RM, or even better: RPE(8, SET_REPS) * SQUAT_1RM)
- Build workouts by re-using pre-defined or even custom blocks
- Share your programs and workouts with others
The core idea is that programs are parametric instead of static. Change your 1RM and the entire program recalculates automatically.
You can try it out without an account at https://vis.fitness/pro/try/create-program
The whole thing is built with NextJS, using Chevrotain (surprisingly solid) for the formula engine.
It's been super interesting using Codex since late Dec. It's been a huge force multiplier, enabling me to ship really cool features like formula autocomplete and syntax highlighting in a couple of hours. I'm used to reviewing a lot of code from my time at Google, so that hasn't been a problem, but it's interesting to feel that the review speed is now the limiting factor. Though the codebase would become unmaintainable real quick without that.
The next step is building an MCP server to allow users to create programs using LLMs and have them show up directly in the editor (and your phone).
Would love feedback, whether you even lift or not!
[0] https://news.ycombinator.com/item?id=31508009
[1] https://apps.apple.com/us/app/vis-next-generation-workouts/i...

value: Show HN: Vis Pro – A Formula-Based Workout Program Editor

author: strongpigeon


value: stackdiver

value: Show HN: Vector database vibe-coded in WASM, 5x faster than JavaScript

author: stackdiver


value: sudoapps

value: Night Watch is a zero-dependency DevOps agent. It uses an LLM agent to run diagnostics, inspect cloud/log signals, and correlate issues with code changes.

value: Show HN: Night Watch, zero-dependency DevOps agent

author: sudoapps


value: Show HN: Dashboard – a runtime plugin-based desktop widget system for Linux


value: lyuata

value:
The Reality: They didn't. But the tech is real. I’ve been building an AI SDR platform and I wanted to share the stack with the HN crowd.
The Project: Babuger
Babuger automates the entire outbound/inbound lifecycle. It trains on your best rep's scripts to qualify leads, handle objections, and book meetings 24/7.
The Problem: Traditional SDR teams are expensive ($150k/yr), have high turnover, and ignore "dead" leads.
The Solution: One human orchestrator managing 20+ specialized AI agents.
The Result: 90% task automation and 70% response rates on neglected pipelines.
The Tech Stack
I kept it modern and modular to handle complex multi-step reasoning:
Agent Orchestration: LangGraph. This was crucial for handling non-linear conversation flows (loops, conditional routing, and state management) that standard DAGs can't touch.
LLM Framework: LangChain. Used for prompt templating, output parsing, and integrating various toolsets (Gmail/Cal.com/HubSpot).
Frontend: Next.js. Managed the dashboard, live email thread previews, and real-time pipeline analytics.
Why I’m Posting
I’m looking for the "HN stress test." Is the agentic approach with LangGraph the right move for scaling to 10k+ interactions/mo, or should I be looking at a more custom state machine?
Check it out: Babuger.com

value: Show HN: OpenAI to Buy Babuger.com for $1B? (Just Kidding, I Built It)

author: lyuata


value: marcelglaeser

value: Show HN: DumpCleaner – Native macOS/iPadOS app to filter SQL dumps

author: marcelglaeser