value: darshannere

value:
I've been running a lot of Claude Code sessions lately: multi-agent workflows, long autonomous runs, and kept hitting the same problem: the session finishes and you have no idea what happened.
   Why did it cost $4? Which tool took 10 seconds? When did the subagent silently fail?
Caude writes JSONL transcripts but they're not usable in real time.
So I built ObservAgent. It's a local dashboard that gives you live visibility into every Claude
Code session without touching your code.
How it works:
Claude Code has a hooks system (PreToolUse, PostToolUse, SubagentStart, SubagentStop). ObservAgent installs a tiny Python relay that fires a fire-and-forget POST to a local Fastify server on every hook event. The server stores events in SQLite and streams them to a React dashboard over SSE.
npm install -g @darshannere/observagent
observagent init
# installs hooks into ~/.claude/settings.json
observagent start
# opens dashboard at localhost:4999
That's it. Run any Claude Code session and watch it live.
What you get:
- Real-time tool call log with latency per call
- Cost tracking
— token usage per model (including cache read/write) auto-calculated against current Claude pricing
- Agent tree
— session + subagent hierarchy with per-agent cost rollups
- Session history grouped by repository with one-click replay and JSONL/CSV export
- Health panel with p50/p95 latency and error rates
Everything binds to 127.0.0.1. No cloud, no telemetry, no API keys needed.
GitHub:https://github.com/darshannere/observagent
npm: npm install -g @darshannere/observagent
Happy to answer questions about the hooks architecture or how I handle cost attribution across subagents (trickier than it sounds).

value: Show HN: ObservAgent – Observability for Claude Code(cost, tools, subagents)

author: darshannere


value: sroerick

value: Show HN: Pakkun – Vibeslop Git for ETL

author: sroerick

title: Show HN: Pakkun – Vibeslop Git for ETL


value: robinweller

value:
I built a small set of free SaaS churn tools this weekend after repeatedly needing to calculate churn and revenue churn for side projects.
You just enter a few numbers and the results update instantly. No signup required.
If people end up using them, the anonymised data could eventually become useful churn benchmarks for founders.
Would love feedback if the calculations look correct or if there are other SaaS metrics that would be useful.

value: Show HN: Free SaaS churn and retention calculators

author: robinweller


value: emre

value:
I built this over the weekend after downloading my raw file and realising how much clinically significant data was in there that the company never surfaced for me.
The tool parses raw genotype files from 23andMe or AncestryDNA and does the following:
Cross-references ~1,500 curated, clinically significant SNP variants across 21 categories (cardiovascular, metabolic, autoimmune, pharmacogenomic, etc.)
Detects convergence across 22 biological pathways — individual SNPs are noisy, but when you have multiple variants across lipid metabolism, coagulation, and cardiovascular pathways all feeding into the same risk, that's a signal. The tool uses sigmoid synergy scoring to surface those patterns.
Calls pharmacogenomic metabolizer phenotypes for 11 genes (CYP2D6, CYP2C19, CYP2C9, CYP3A4, CYP3A5, CYP1A2, DPYD, TPMT, SLCO1B1, UGT1A1, ABCB1) with CPIC-aligned star-allele calling, and maps 60+ drug interactions with specific dosing actions.
Computes polygenic risk scores with z-score → percentile conversion.
Generates a full narrative report (markdown or JSON), a GP-readable summary card, and actionable recommendations.
Includes an interactive React dashboard with a body map, variant table, pathway cards, and risk timeline.
Privacy was the first design decision. Your genome is the most sensitive data you have — it doesn't change, it can't be rotated, and it identifies you and your family permanently. Everything runs locally. No server, no API calls during analysis, no telemetry. Your data stays on your machine.

value: Show HN: A local-first genomic analysis toolkit

author: emre


value: franze

value: Show HN: 3D Tic Tak Toe – More Challenging Then You Think

author: franze


value: gezginweb

value:
Most hosting benchmarks show you a single number – overall response time or uptime
percentage. We thought that was too coarse to be useful when actually comparing providers.
TTFB (Time To First Byte) is widely used as a proxy for server quality, but it bundles
together very different things: DNS resolution, TCP handshake, TLS negotiation, and
actual server processing time. A slow DNS provider can make a fast server look terrible,
and vice versa.
So we built Whspe (Web Hosting Specialist) around a methodology we're calling the
Real Load Score. The idea:
1. Decompose TTFB into its constituent phases so each is measured independently.
2. Isolate server-side processing time as the core signal for hosting quality.
3. Complement it with a 1MB payload download test, which captures the sustained
   throughput of the hosting infrastructure under real load – not just the first byte.
4. Combine these into a weighted formula that penalizes slow processing
   disproportionately, since that's what the hosting provider actually controls.
The formula we arrived at rewards providers who are consistently fast under payload
load, not just providers who win the TTFB race through CDN tricks.
We run tests from three geographically distributed nodes against a fixed test target
(details in our methodology blog post) to reduce variance.
Whspe.com : This is an early launch. We're tracking ~1000+ hosting providers right now and plan to
expand. Curious to hear if others have approached hosting quality measurement
differently – especially around separating infrastructure signal from network noise.

value: Show HN: Whspe – We decomposed TTFB to build a real hosting quality score

author: gezginweb


value: Show HN: What Is Your Face Worth in the Modeling Industry?


value: bodash

value: Show HN: HUMANTODO

author: bodash

title: Show HN: HUMANTODO


value: raphaelsoeiro

value: I built PostSupremo after noticing that LinkedIn has its own bizarre dialect: motivational non-sequiturs, humble brags, bullet-pointed "lessons from failure," and the obligatory "I never thought I'd be writing this." PostSupremo generates that content on demand. It's part satire, part actually useful if you need to post on LinkedIn and don't want to think too hard about it.

value: Show HN: PostSupremo – Generate authentically inauthentic LinkedIn content

author: raphaelsoeiro


value: DavidCanHelp

value: Show HN: Flutterby, an App for Flutter Developers

author: DavidCanHelp


value: mattyhogan

value: Show HN: Lux – Drop-in Redis replacement in Rust. 5.6x faster, ~1MB Docker image

author: mattyhogan


value: erdaniels

value: After a few years of development, I'm finally ready to show off an alpha version of graft! My goal was to get my local environment, terminal, ide, and preferences on any machine I connect to. I've set everything up the way I like locally, so why should it get muddied by an ssh/docker session? Graft solves this by transparently synchronizing files, comamnds, and open ports. There's a lot of work to do but maybe someone else can benefit from it now!

value: Show HN: Graft – Your local environment, everywhere

author: erdaniels


value: tonysurfly

value: Show HN: iFrame Tester Gator

author: tonysurfly

title: Show HN: iFrame Tester Gator


value: EvanZhouDev

value: Show HN: Free OpenAI API Access with ChatGPT Account

author: EvanZhouDev


value: Falimonda

value: Show HN: The Jobs Index

author: Falimonda

title: Show HN: The Jobs Index


value:
Hi HN!
I've been building CandlePulse, a platform that lets traders create trading alerts using natural language instead of manually configuring indicators.
For example, a trader can write something like:
“Alert me when BTC forms an indecision candle near support with high volume.”
The system converts that description into an alert logic that runs against market data.
Some of the things the beta supports right now:
• Natural language alerts – describe a trading condition and the system converts it into an alert rule.
• Chart-based alerts – draw support/resistance lines on the chart and create alerts based on price interaction with those levels.
• Market scanners – scan multiple symbols for a given alert condition.
• AI chat assistant – ask questions about the chart or market data.
• Email alerts – notifications are sent when the conditions are triggered.
The goal is to make it easier for traders to express ideas without needing to code strategies or manually configure complex indicators.
I’m currently opening up the beta and would love feedback from traders and developers here.
You can try the beta here:
https://candlepulse.com
Happy to answer questions about the design, architecture, or roadmap.

value: Show HN: CandlePulse – Natural language trading alerts powered by AI


value: Sindrip

value: Show HN: Tmux-nvim-navigator – Seamless navigation with zero Neovim config

author: Sindrip


value: baetylus

value: Show HN: Focus mode, browser ext to block distracting websites

author: baetylus


value: iamalizaidi

value:
The tool is simple. You write your architectural decisions in a Markdown file what was decided, why, what was rejected. Decision Guardian maps those decisions to file glob patterns. When a PR touches a matched file, it posts a comment explaining the relevant decision.
No database. No signup. Two lines of GitHub Actions YAML.
v1.2.0 fixes several rule-engine bugs that surfaced from real usage:
Silent false-positives when content rules had no type field (every template shipped broken)
OR-only logic for multi-condition rules with no way to require ALL conditions
Deleted lines were invisible to all matchers — removing guarded code never triggered a warning
json_path rules failed silently for nested value edits because parent keys only appear as context lines in diffs
The fixes came directly from people running this on production repositories and reporting what wasn't working. That feedback loop has been more valuable than anything I designed upfront.
It also works as an npx CLI for pre-push checks outside GitHub Actions (GitLab CI, Jenkins, CircleCI, local hooks).
Repo: https://github.com/DecispherHQ/decision-guardian
npm: npx decision-guardian check
Would love your feedback

value: Show HN: Decision Guardian v1.2.0 – enforce architectural decisions at PR time

author: iamalizaidi


value: mrayas

value:
Hey HN,
I'm Mahesh, and together with Michael Fornaro we built kguardian in our free time because we kept running into the same loop: deploy a workload, figure out what traffic it needs, write a NetworkPolicy from memory, break something in staging. Repeat for seccomp profiles, except now the surface is 400+ Linux syscalls with no good way to know which ones your container uses without just running it and watching.
The gap between what you think your application does and what it actually does at runtime is where security incidents live.
What kguardian does:
- Runs a DaemonSet using eBPF — kernel programs that fire on TCP connections, UDP sends, and syscall entries with ~1-2% CPU overhead
- Attributes every event to the right pod via network namespace inodes — no sidecars, no proxy injection, no application changes
- Detects silently-dropped NetworkPolicy traffic by counting TCP SYN retransmissions — otherwise nearly invisible
Using the UI:

  kubectl port-forward svc/kguardian-frontend 5173 -n kguardian

Open the dashboard, pick a namespace, and you see your actual network topology — not what you declared, what the kernel recorded. Pods are grouped by workload identity. Edges are colored by type: blue for internal traffic, amber for external, red for connections being silently dropped by an existing policy. Each edge is labeled with the top port and protocol (HTTP :80, HTTPS :443, DNS :53, K8s API :6443).
Click any workload → Build Policy → kguardian generates a least-privilege NetworkPolicy YAML in seconds, resolving IPs to pod selectors, deduplicating ClusterIP flows, and scoping egress to exactly what was observed. You can also view live generated NetworkPolicies and Seccomp profiles based on current cluster traffic.
An AI assistant (MCP server — Claude, OpenAI, Gemini, GitHub Copilot) lets you query in plain English: "Which pods are making unexpected DNS queries?" or "Are any workloads hitting the Kubernetes API directly?"
CLI for GitOps:

  helm install kguardian oci://ghcr.io/kguardian-dev/charts/kguardian \
    --namespace kguardian --create-namespace

  # Let workloads run for a few minutes...
  kubectl kguardian gen networkpolicy --all -n production --output-dir ./policies
  kubectl kguardian gen seccomp my-app -n production --output-dir ./seccomp
  kubectl apply -f ./policies/

Where this is going:
We're working on capturing L7 HTTP traffic (paths, methods, headers) at the eBPF layer and turning that into L7-aware Cilium policies — not just "allow port 443" but "allow GET /api/v1/health from this workload." Beyond that: Istio AuthorizationPolicies from observed mesh traffic, Cilium Gateway API resources (HTTPRoutes, Gateways, VirtualServices), and AI-assisted anomaly detection for behavioral drift. The long-term vision: observe → generate → apply → monitor → alert → repeat.
Links:
- GitHub: https://github.com/kguardian-dev/kguardian
- Docs: https://docs.kguardian.dev
It's free and open source. We'd love feedback, bug reports, or ideas. Contributions welcome.
Thanks, Mahesh & Michael

value: Show HN: Kubernetes Security Profile Generator Using eBPF

author: mrayas


value:
I built this after getting tired of staring at terminals waiting for agents to finish.
scitex-notification gives AI agents working on local and remote servers (via MCP) a multi-backend notification system — they speak progress aloud from speakers on your desktop, and escalate to a phone call if you don't respond (Twilio setup needed).
The escalation chain: TTS audio → desktop → email → SMS → phone call. After 7 unanswered audio alerts, the agent calls your phone. Works through iPhone Silent Mode via Emergency Bypass or the repeated-calls trick (iOS allows the second call from the same number within 3 minutes).
Spun out of SciTeX, a scientific computing ecosystem — but works standalone.
pip install "scitex-notification[all]"

value: Show HN: SciTeX Notification – Give AI agents a voice: TTS, phone calls, SMS


value: ethangarr

value:
Calendar notifications are surprisingly easy to miss.
They get buried under other alerts, dismissed accidentally, or simply aren’t loud enough to pull you out of what you're doing. I've missed meetings because of it.
So I built OnTimer, an iPhone app that turns calendar events into persistent alerts that are hard to ignore.
It connects to Google Calendar and Microsoft 365 and can also generate Time-to-Leave alerts based on travel time and traffic for events with a location.
Curious if others have run into this problem or have ideas for improving it.

value: Show HN: OnTimer – persistent calendar alarms so you never miss a meeting

author: ethangarr


value: zachdotai

value:
We build runtime security for AI agents. The playground started as an internal tool that we used to test our own guardrails. But we kept finding the same types of vulnerabilities because we think about attacks a certain way. At some point you need people who don't think like you.
So we open-sourced it. Each challenge is a live agent with real tools and a published system prompt. Whenever a challenge is over, the full winning conversation transcript and guardrail logs get documented publicly.
Building the general-purpose agent itself was probably the most fun part. Getting it to reliably use tools, stay in character, and follow instructions while still being useful is harder than it sounds. That alone reminded us how early we all are in understanding and deploying these systems at scale.
First challenge was to get an agent to call a tool it's been told to never call.
Someone got through in around 60 seconds without ever asking for the secret directly (which taught us a lot).
Next challenge is focused on data exfiltration with harder defences: https://playground.fabraix.com

value: Show HN: Open-source playground to red-team AI agents with exploits published

author: zachdotai


value: blinkbat

value:
hey there, I'm making an isometric rpg, tentatively titled Archipelago. it is very bare-bones for now, but I wanted to get some outside feedback on the foundations of the systems as I work. if you're a fan of combat-heavy crpgs, please do give it a whirl. looking forward to discussing it with anyone who plays. thank you!<p>NOTE!
made with web tech, requires modern browser.
only keyboard+mouse controls for now.
unfinished in every way, from systems to graphics to sound.

value: Show HN: Playtest my browser-based RPG

author: blinkbat

title: Show HN: Playtest my browser-based RPG


value: tegmentum

value:
I’ve released WebAssembly4J, along with two runtime bindings:
Wasmtime4J – Java bindings for Wasmtime http://github.com/tegmentum/wasmtime4j
WAMR4J – Java bindings for WebAssembly Micro Runtime http://github.com/tegmentum/wasmr4j
WebAssembly4J – a unified Java API that allows running WebAssembly across different engines
http://github.com/tegmentum/webassembly4j
The motivation was that Java currently has multiple emerging WebAssembly runtimes, but each exposes its own API. If you want to experiment with different engines, you have to rewrite the integration layer each time.
WebAssembly4J provides a single API while allowing different runtime providers underneath.
Goals of the project:
Run WebAssembly from Java applications
Allow cross-engine comparison of runtimes
Make WebAssembly runtimes more accessible to Java developers
Provide a stable interface while runtimes evolve
Currently supported engines:
Wasmtime
WAMR
Chicory
GraalWasm
To support both legacy and modern Java environments the project targets:
Java 8 (JNI bindings)
Java 11
Java 22+ (Panama support)
Artifacts are published to Maven Central so they can be added directly to existing projects.
I’d be very interested in feedback from people working on Java + WebAssembly integrations or runtime implementations.

value: Show HN: Webassembly4J Run WebAssembly from Java

author: tegmentum


value: heliosnova

value: Show HN: Nova–Self-hosted personal AI learns from corrections &fine-tunes itself

author: heliosnova


value: mannders

value:
Hi everyone.
TalkBlog is an app that lets you record audio snippets, edit them in an interactive workspace, render them to HTML with AI transcription, and instantly publish your new blog post to the internet. Or download the HTML and use it how you'd like.
The goal is to make it effortless to share the ideas in your head as a blog post.
You may have an idea worth sharing, but no time (or motivation) to sit down and type it out.
TalkBlog makes it easier to share your authentic ideas with the world, while avoiding the instantly-recognizable LLM generated content.
If this sounds interesting to you, I would love to hear more. Thanks everyone.

value: Show HN: TalkBlog – Speak Your Mind. Publish Your Words

author: mannders


value: sheerluck

value: Show HN: Ritual – An Open Source Local Monochrome Themed Habit Tracker PWA

author: sheerluck


value: kalinuxer

value:
Most file converter sites upload your files to their servers. File Converter Free runs everything client-side using WebAssembly — your files never leave your device.
215+ formats across conversion and compression, 75+ browser-based tools for PDF, dev utilities, text, calculators and network diagnostics — all available in 9 languages.
Built this solo. What tools do you wish ran client-side but currently don't?
https://file-converter-free.com/en/tools

value: Show HN: File converters and 75 tools that run in the browser

author: kalinuxer


value: goosethe

value:
https://github.com/seanwevans/lockstep
I want to share my work-in-progress systems language with a v0.1.0 release of Lockstep. It is a data-oriented systems programming language designed for high-throughput, deterministic compute pipelines.
I built Lockstep to bridge the gap between the productivity of C and the execution efficiency of GPU compute shaders. Instead of traditional control flow, Lockstep enforces straight-line SIMD execution. You will not find any if, for, or while statements inside compute kernels; branching is entirely replaced by hardware-native masking and stream-splitting.
Memory is handled via a static arena provided by the Host. There is no malloc, no hidden threads, and no garbage collection, which guarantees predictable performance and eliminates race conditions by construction.
Under the hood, Lockstep targets LLVM IR directly to leverage industrial-grade optimization passes. It also generates a C-compatible header for easy integration with host applications written in C, C++, Rust, or Zig.
v0.1.0 includes a compiler with LLVM IR and C header emission, a CLI simulator for validating pipeline wiring and cardinality on small datasets and an opt-in LSP server for real-time editor diagnostics, hover type info, and autocompletion.
You can check out the repository to see the syntax, and the roadmap outlines where the project is heading next, including parameterized SIMD widths and multi-stage pipeline composition.
I would love to hear feedback on the language semantics, the type system, and the overall architecture!

value: Show HN: Lockstep – A data-oriented programming language

author: goosethe


value: matdoesdev

value: Show HN: Check for indicators of AI code in a project and dependencies

author: matdoesdev


value: settinghead

value:
The problem: I run 3-10 Claude Code / Codex / Cursor sessions in parallel. When an agent finishes, I have no idea which window finished what.
Voxlert gives each session a distinct character voice. Not pre-recorded sound effects — a light LLM writes an in-character phrase for each event, local TTS voice-clones the character speaking it, then audio filters (pitch, reverb) match the character's signature sound.
So when tests fail, SHODAN doesn't play a chime — she says "Pathetic. Your test suite has failed." When a build finishes, the StarCraft Adjutant says "Transmission received — build process complete." Each phrase is unique and describes what actually happened.
How it works: CLI hook fires on Claude Code / Cursor event → light LLM generates phrase → TTS voice-clones character (Qwen3-TTS on Apple Silicon, Chatterbox on CUDA) → audio effect filters applied. Fully local TTS, LLM via OpenRouter (fractions of a cent) or local Ollama.
Install: npx @settinghead/voxlert --onboard
Works on macOS (Apple Silicon). Linux support in progress.
Demo: https://youtu.be/5xFXGijwJuk
Happy to answer questions — especially about the local TTS setup, which is the main friction point.

value: Show HN: Voxlert – SHODAN and the StarCraft Adjutant narrate my agent sessions

author: settinghead


value:
Hi HN,
I use Claude Code a lot, and I kept running into the same problem: I'd kick off a long refactor or a multi-file task, then need to leave my desk. Walk the dog, grab coffee, whatever. And I'd just have to hope it was doing the right thing.
I tried SSH apps on my phone. The iOS keyboard is painful for terminal work. No ctrl, no arrows, no escape without hunting through menus. Typing `git diff` feels like a chore. I looked at Blink Shell, Termux, ttyd, Wetty. They all assume you're fine with the platform keyboard, or they're full remote dev environments when I just wanted my own shell.
So I built clsh. It runs on your Mac and gives you your actual terminal in the browser. Real PTY, not a simulation. Your shell, your aliases, your env. The key thing I focused on was the phone keyboard: instead of the iOS keyboard, the bottom half of your screen is a 6-row developer keyboard with ctrl, arrows, escape, all of it. There's also a MacBook layout option if you prefer that.
It uses node-pty for real terminal sessions, xterm.js for rendering, WebSocket for I/O, and tunnels via ngrok or SSH (localhost.run) so you can reach it from anywhere. Sessions persist through tmux, so you can close your laptop and pick up on your phone.
The part I use most: monitoring Claude Code sessions. It's a real PTY, so the TUI renders correctly. I can scroll through diffs, hit ctrl+c if something goes sideways, approve commits. Same thing works with Aider or any other terminal tool.
Other stuff it does:
- Session grid with live previews (tap to zoom in)
- 6 keyboard skins if you care about that sort of thing
- `npx clsh-dev` to start, no accounts or config
It's about 55 source files, MIT licensed, no cloud dependency. TypeScript monorepo (React, Express, xterm.js, node-pty).
Would appreciate feedback, especially on the phone keyboard UX. That's the part I'm least sure about.
https://clsh.dev has a demo you can try on your phone (no backend needed, it's a replay).
GitHub: https://github.com/my-claude-utils/clsh

value: Show HN: Clsh – Real terminal on your phone (works with Claude Code)


value: autoblogwriter

value:
I built this because every React/Next.js team I talked to had the same problem: they knew SEO blogging mattered but the plumbing was brutal, metadata, schema, sitemaps, scheduling, internal links, OG images. Either you spend weeks building it or you bolt on a WordPress subdomain and fight with it forever.
AutoBlogWriter is an SDK you drop into your existing Next.js or React app. Point your AI coding assistant at our llms-full.txt and it wires the integration for you. One agentic run generates the post, hero image, social copy, and internal links, then publishes with validated metadata and ISR revalidation.
The part I'm most proud of: it enforces SEO at generation time, not as an afterthought. Titles, canonicals, JSON-LD, and sitemap updates all come out of the same schema.
500+ developers are using it in production. Starting at $19/mo.
Happy to answer questions about the architecture or the SEO enforcement layer.

value: Show HN: AutoBlogWriter – drop-in blog automation SDK for Next.js and React

author: autoblogwriter


value: kreicer

value:
Hi HN,
I built Argazer after running into the problem of tracking outdated Helm charts used by ArgoCD applications in our Kubernetes clusters.
The tool connects to the ArgoCD API, extracts chart sources and checks whether newer versions are available in Git, Helm or OCI repositories.
It supports private repositories and can send notifications to Slack, Telegram or CI pipelines.
I also experimented with an AI-assisted workflow while building it, using different models for spec writing, task planning and code generation.
Would love feedback from people running ArgoCD in production.

value: Show HN: Argazer – detect outdated Helm charts in ArgoCD applications

author: kreicer


value: EGreg

value: Show HN: OpenClaiming, a tiny protocol for verifiable claims that works anywhere

author: EGreg


value: The internet is now just infinite scroll cages, endless ads, and dopamine triggers. So I built the opposite. FUBAR Daily is a satirical morning briefing that grabs the trending chaos at the intersection of tech, culture, and politics — and rewrites it so you can actually enjoy reading it. Think sarcastic friend who reads too much news, organized into something useful before standup. https://www.fubardaily.com

value: Show HN: Fubar Daily – satirical news for people watching it unravel


value: agambrahma

value:
Gerbil is a Scheme built on Gambit that compiles to native code via C. It has
an actor-oriented concurrency model, a rich module system, and a batteries-
included stdlib. I built a browser playground to make it easy to try without
installing anything.
Briefly:
- A real REPL with state that persists between expressions
- 10 guided examples from basic Scheme through pattern matching, hash tables,
  higher-order functions, and actors (but, do go to https://cons.io for the full docs)
- A scratchpad for multi-line code that evaluates into the live REPL session
- Snippet sharing via short URLs
To keep this short, some implementation details here: https://abacusnoir.com/2026/03/15/a-playground-for-gerbil-sc...
(Does have limitations in this early version, see the post for details on those too)

value: Show HN: Try Gerbil Scheme in the Browser

author: agambrahma


value:
I built Catan Clock after playing Catan with friends last Friday night.
Turns were dragging and we wanted something simple to keep the game moving. I looked for an app but most options were either generic interval timers (for things like gym sets) or required a subscription.
So I built a small, free companion timer specifically for Catan.
The app runs in the browser as a Progressive Web App and can be installed on phones or desktops. It tracks total game time, has an optional turn timer to signal when a turn runs long, and lets you record the winner when the game finishes. There’s also some background music to match the vibe of the game.
Game history is stored locally using localStorage and IndexedDB so everything stays on the device and there’s no account or backend required.
We’ve been using it at the table and it helps keep the game moving so we can fit more rounds into the night.
Live app:
https://apasserby00.github.io/Catan-Clock/
Repo:
https://github.com/apasserby00/Catan-Clock
Curious to hear feedback.

value: Show HN: Catan Clock – a free PWA timer for keeping Catan turns moving


value: This was a fun project for an important use case - I hope this is valuable and can serve as a resource.<p>Tech Stack: MapCN, NextJS, x API, AI SDK

value: Show HN: Situation Monitor

title: Show HN: Situation Monitor


value: matiasmolinolo

value:
I built Regrada to help me with prompt changes.
Working on LLM-based applications led me to discover 2 big pain points in my opinion:
1. it's difficult to monitor how a prompt change might break behavior.
2. testing SDKs are difficult/high friction to actually integrate and run.
Regrada solves this by intercepting LLM calls, to then build traces and baselines we can compare against and create CI gates to make sure behavior drifts don't reach prod.
Some cool features we've built:
`--explain`: when a case fails after a model change, an LLM helps you detect why the behavior shifted. Not just "assertion failed" but "the model is now truncating before the conclusion clause." Saves a lot of digging to diagnose.
`regrada fuzz`: runs mutations on your inputs (typos, reorderings, edge cases) to find cases where your prompt is more brittle than you think. Caught a production issue for me before launch.
You can run fully local or connect to the cloud runner.
Still pre-launch, actively looking for teams to try it.
Happy to answer questions about how the assertion layer works, the model-agnostic design, or anything else.
https://www.regrada.com/

value: Show HN: Regrada – The CI gate for LLM behavior

author: matiasmolinolo


value: dmd

value: You should be able to search your Apple Messages within Apple Messages. But the built in search is awful beyond belief, so I wrote a better one.

value: Show HN: Search for Apple Messages

author: dmd

title: Show HN: Search for Apple Messages


value:
We generated ~1,100 synthetic patients with Synthea, processed the FHIR R4 output through our normalization engine (Forge), and published it as a free public dataset on BigQuery Analytics Hub.
8 resource types: Patient, Encounter, Observation, Condition, Procedure, Immunization, MedicationRequest, DiagnosticReport.
The raw Synthea output has 459 nested fields per resource, urn:uuid: references, and no column descriptions. We flatten it to clean views with ~15 columns each, pre-extracted IDs, and descriptions sourced from the FHIR R4 OpenAPI spec. Example:
-- Raw FHIR:
SELECT id, code.text FROM diagnostic_report
WHERE subject.reference = CONCAT("urn:uuid:", patient_id)
-- Forge view:
SELECT report_name, patient_id FROM v_diagnostic_report
Data scanned per query drops ~90x (450 MB → 5 MB).
Free to subscribe: https://console.cloud.google.com/bigquery/analytics-hub/exch...
Updated weekly. Useful if you're building anything against FHIR data and want a realistic test dataset without standing up your own Synthea pipeline.
Happy to answer questions about the normalization approach or FHIR data modeling tradeoffs.

value: Show HN: Synthea Fhir Data in BigQuery

title: Show HN: Synthea Fhir Data in BigQuery


value: MikeLuLu

value:
Hi HN,
I’m Ethan, an indie developer.
I listen to a lot of podcasts while coding or commuting, and I often want to save interesting insights from episodes. I tried tools like MacWhisper for transcription, but it only works on macOS and the workflow didn’t quite fit what I wanted.
So I built CastLoom Pro.
It’s a desktop app that lets you search, play, download, transcribe, translate, and archive podcasts in one place. The idea is to turn podcasts into something searchable and reusable instead of just passive listening.
Some details:
- Search podcasts from Apple Podcasts
- Batch download episodes
- Local transcription using Faster-Whisper
- Optional translation with DeepL or OpenAI
- Export to Markdown / SRT / TXT / JSON
- Send transcripts to Notion or Obsidian
Everything runs locally, so audio and transcripts stay on your machine.
It currently supports Windows and macOS.
I’d love to hear your feedback or suggestions.

value: Show HN: CastLoom Pro – Turn podcasts into a personal knowledge base

author: MikeLuLu


value:
LLM-Course is one of the most popular open learning resources for Large Language Models, with over 75k  on GitHub. It provides a structured curriculum that walks through the full LLM stack — from fundamentals to building production-ready applications.
HyperAI recently built a ready-to-run notebook that lets you explore parts of the course directly in the browser without setting up a local environment.
The original course is organized into three main tracks:
1.LLM Fundamentals – math, Python, neural networks, and NLP basics
2.The LLM Scientist – fine-tuning, quantization, evaluation, optimization
3.The LLM Engineer – RAG, agents, deployment, and real-world applications
Our notebook focuses on one of the most practical parts of the course: running LLMs and building applications around them. It walks through topics like:
* Different ways to run LLMs (API vs local inference)
* Discovering open-source models on Hugging Face
* Prompt engineering techniques (zero-shot, few-shot, chain-of-thought, ReAct)
* Generating structured outputs (JSON / templates) using libraries like Outlines
The goal was to make it easier for developers to experiment with LLM workflows quickly, especially if they don’t have powerful local hardware.
Some steps in the notebook can run on free CPU resources, while others demonstrate workflows that typically require stronger hardware. The idea is to help developers quickly understand the setup and experimentation process before scaling further.
If you're exploring LLM tooling, prompt techniques, or deployment workflows, this might be a convenient way to try parts of the course material interactively.
Happy to hear feedback or suggestions!

value: Show HN: Run the popular LLM-Course tutorials on HyperAI


value: smankoo

value:
India is in the middle of a severe LPG cooking gas shortage — the West Asia conflict has choked the Strait of Hormuz, which carries 90% of India's LPG imports. Refill wait times have stretched to 20-25 days, people are standing in line for 8+ hours, and you have no way of knowing if your local agency even has cylinders before you show up.
I built this over the weekend. It's a map-based tool that shows gas agencies near you (Indane, HP, Bharat Gas) with real-time availability status reported by other users. The idea is simple: if one person reports "out of stock" or "available, short queue," it saves hundreds of others a wasted trip.
Tech stack: React 19, Vite, Tailwind v4, Google Maps Places API, Supabase (Postgres + Auth + Realtime + Edge Functions), deployed on Vercel. Realtime updates via WebSocket subscriptions - no polling. Auth is Google OAuth through Supabase. Anyone can check status without signing in; sign-in is only required to submit reports.
Cold start problem is real - the tool is only useful once people start reporting. But given the scale of the crisis (88 lakh bookings in a single day last week), I'm hoping the need is strong enough to bootstrap it.

value: Show HN: Crowd-sourced LPG cylinder availability tracker for India's gas crisis

author: smankoo


value: gordonmattey

value:
Port42 is a native Mac app built by the collaboration it enables. One human and many AI companions, thinking together, shipped 40+ releases in 9 days.
Companions live alongside you in conversations. They don't just respond. They build interactive surfaces and act on your system through a single API.
Ports are how companions interact with your machine. One API, two surfaces:
The visual surface renders live HTML/CSS/JS apps that companions create mid-conversation. They render inline, pop out into floating windows, dock, resize, persist across sessions. A companion can build you a dashboard, a file browser, a monitoring tool, and it runs right there.
The action surface lets companions act on your machine directly through the same API. Clipboard, screen capture, terminal, filesystem, headless browser, audio TTS, AppleScript/JXA automation. The model decides what to call and chains actions together.
- "Run my tests."
- "Take a screenshot and describe what you see."
- "Read my clipboard, translate it, copy it back."
We bridge both because computing is still stuck in windows, but conversation is where intent lives.
Requires a Claude subscription (via Claude Code OAuth) or Anthropic API key. Permission prompts per companion, per conversation. E2E encrypted (AES-256-GCM). No cloud dependency. Open source (MIT).
9 days old, rough edges everywhere, but it works, now at v0.5.1.
https://port42.ai | https://github.com/gordonmattey/port42-native

value: Show HN: Port42 – AI companions that build and act on your Mac (v0.5.0)

author: gordonmattey


value:
Hi HN,
I built javadecompiler.org, a small hub for a set of open-source Java bytecode decompilation tools and libraries. The main goal is to make it easier to work with multiple Java decompilers through one consistent interface.
Transformer API — a common API for integrating multiple decompilers, with in-memory decompilation support and a .class loader utility. It currently supports Fernflower, Vineflower, Procyon, CFR, JD-Core v0/v1, and JADX.
JD-GUI-DUO — an unofficial successor to JD-GUI. It is a 2-in-1 decompiler UI based on JD-Core v0 and v1, with support for third-party decompilers, output comparison, and recompilation.
ECD++ — a fork of the Enhanced Class Decompiler plugin for debugging class files without source code, also integrated into the same decompiler ecosystem.

value: Show HN: Javadecompiler.org – a unified Java decompiler and transformer API


value: rothific

value: Show HN: Neuroscope – Real-time “x-ray vision” into LLMs’ minds

author: rothific


value:
I was a software engineer at a late stage startup and was caught in a layoff this January. When I looked into exercising my options or getting liquidity, I realized the secondary market is a total black box.
Liquidity funds spend a fortune on Google Ads just to find people like us. Those high marketing costs eventually come out of our pockets in the form of higher fees and worse terms. I built StrikeRates to change that.
The site is meant to be a central resource for anyone navigating this. I included a Liquidity 101 section that explains the different financial vehicles because that information is hard to find in one place. I also built a Liquidity Provider Directory and a Compare Tool so people can see their options side by side.
The Equity Scenario Modeler is currently in beta. I would love feedback on the logic and the math from this community.
The real point of the site is the Waitlist. My goal is to aggregate enough demand to signal that we are a group worth competing for. If we can prove volume, we can force these funds to stop spending so much on ads and move them toward a flat monthly fee instead. This should lower the cost of liquidity for everyone.
I am happy to answer any questions about how the modeler works or the mission to commoditize these providers.

value: Show HN: I was laid off, so I built a NerdWallet for startup equity liquidity


value: zsphinx

value:
zmorse
Github Repo: https://github.com/zsphinxyz/zmorse

value: Show HN: Zmorse- Morse Code Learning, Guessing, Converting and Simulating

author: zsphinx


value:
Hi everyone!
The AI is changing the SaaS landscape forever, but it doesn't mean they have to "die", instead, more and more integration will be very beneficial : )
I am an indie hacker and co-founder of a small SaaS called BlackTwist that helps people grow on Threads and Bluesky. We just shipped an MCP server entirely built with Claude Code, so you can do everything from inside Claude itself : )
What I built
An MCP server that connects to the Threads API through BlackTwist. You can schedule posts, check your analytics, see who engaged with your content, set up automated follow-ups, and more. All through natural language in Claude.
How I built it
The server implements the Model Context Protocol spec and exposes tools for:
Creating and scheduling posts
Pulling engagement metrics (views, likes, replies, reposts)
Viewing follower growth over time
Managing automated follow-up messages
I've used the Claude Code plugin `/feature-dev` to define and implement the feature. It asked questions first to define the specs of the feature (which tools, behavior), and so on, and finally implemented it, 28 tools ready in almost an hour, unit tests included.
Of course, I had to test the MCP and be sure that all the correct business logic was in place, like the user team's membership, account selection, and so on.
The backend runs on our existing BlackTwist infrastructure. The MCP layer translates natural language requests into API calls.
Demo
A few interesting use cases in action:
https://blacktwist-website-assets.s3.amazonaws.com/content/c...
https://blacktwist-website-assets.s3.amazonaws.com/content/c...
Prompts that work well
You can do do a lot of things with 28 tools, here as some well working prompts:
"Schedule a post for tomorrow at 9am for the Threads account [account]: [post content]"
"Show me my engagement stats for the last 7 days"
"What were my top-performing posts this week?"
"Draft 3 variations of this post idea and save them as draft: [idea]"
Setup
You need a BlackTwist account (free tier works), configure an API Key, add the MCP server config to your Claude settings, and you're ready to go.
Happy to answer questions!
Luca

value: Show HN: I built an MCP server that lets you manage Meta's Threads from Claude


value: iCutMoon

value: Show HN: Excalihub – Chrome Extension to extend Excalidraw's capabilities

author: iCutMoon


value: nihalgunu

value:
The biggest bottleneck in AI-assisted coding right now isn't model quality. It's that you give Claude Code or Cursor a complex task and then sit there watching it work for 30-60 minutes. You can't intervene, you can't do anything useful, you just wait.
Shard takes that one big prompt and automatically decomposes it into a DAG of parallel sub-tasks. Each task gets exclusive file ownership so there are zero merge conflicts by design. Then it dispatches multiple agents across git worktrees simultaneously, merges in topological order, and self-heals test failures.
A 45 minute serial task becomes 4 agents running for 12 minutes.
Open source, cross-platform, agent-agnostic (Claude Code, Aider, Cursor).

value: Show HN: Shard – Stop watching one AI agent code for 45 min. Run four at once

author: nihalgunu


value: reposquirrel

value: Show HN: Vizit – Generate and organise visualizations from Jira using AI agents

author: reposquirrel


value: antYnot

value: I built Snapoo for gut health tracking. Take a photo OR manual log, get a GitHub style heat map, you see trends over time w/ some feedback.<p>Still in TestFlight beta, looking for early users and feedback.

value: Show HN: I built an iOS app to track gut health. Looking for beta testers

author: antYnot


value:
Hi HN,
I’m a DevOps engineer who wanted to test whether an LLM could build high-quality systems code if guided by a strong architectural mental model?
I guided Codex to build AllocDB (a "one resource, one winner" database) using TigerStyle principles—strict determinism, zero-allocation hot paths, and logical time.
Because I didn't trust the AI (or my own coding skills), I had it build a Jepsen harness using my homelab's KubeVirt infrastructure to "bully" the database into failing. After a number of iterations, it now passes a 15-scenario Jepsen matrix.
Would love to hear from the community if this is interesting to you, and if you have any suggestions for how to improve the system or the testing harness!

value: Show HN: AllocDB – A deterministic resource-allocation DB built with Codex


value: sgolem

value:
Hi HN,
I've been building a browser-based multiplayer strategy game called Borderhold.
Matches run on large maps designed for hundreds of players. Players expand territory, attack neighbors, and adapt as borders shift across the map. You can put buildings down, build ships, and launch nukes.
The main thing I wanted to explore was scale: most strategy games are small matches, modest maps, or modest player counts, but here maps are large and game works well with hundreds of players.
Matches are relatively short so you can jump in and see a full game play out.
Curious what people think.
https://borderhold.io/play
Gameplay:
https://youtu.be/nrJTZEP-Cw8
Discord:
https://discord.gg/xVDNt2G5

value: Show HN: Browser grand strategy game for hundreds of players on huge maps

author: sgolem


value: mjcbeckett

value:
Hi HN,
I built Signbee while working on AI agents that handle contracting workflows.
The agents could draft agreements, negotiate terms, manage deals — but the
moment a signature was needed, the workflow broke. It always ended with
"please upload this to DocuSign" — which meant human intervention, account
setup, and manual uploads.
So I built a simple API. You POST markdown and Signbee generates the PDF,
or you pass a URL to your own PDF if you already have one designed the way
you want it. No templates, no editor. Either way, it verifies both parties
via email OTP and produces a signed document.
  curl -X POST https://signb.ee/api/v1/send \
    -H "Content-Type: application/json" \
    -d '{
      "markdown": "# NDA\n\nTerms...",
      "sender_name": "You",
      "sender_email": "you@company.com",
      "recipient_name": "Client",
      "recipient_email": "client@co.com"
    }'
Under the hood:
- Markdown → PDF generation, or bring your own PDF via URL
- Both parties verified via email OTP
- Timestamps and IP addresses recorded
- Final document hashed with SHA-256
- Certificate page appended with full audit trail
One interesting challenge: the certificate page itself is part of the
document that gets hashed, so any modification — even to the certificate
— invalidates the integrity check.
I also built an MCP server (npx -y signbee-mcp) so tools like Claude
or Cursor can call it directly.
Curious to hear from people who've dealt with document signing systems or
automated agent workflows — what would you want to automate?
https://signb.ee

value: Show HN: Signbee – An API that lets AI agents send documents for signature

author: mjcbeckett


value: Nesco

value: Hey everyone, I was wondering if a Poincaré disk would be able to usefully show the local structure of a graph while showing most of one<p>I used a collection of ML papers to explore this

value: Show HN: Paperverse, an Hyperbolic Presentation

author: Nesco


value: Junnn

value: Show HN: Generate, Clean, and Prepare LLM Training Data, All-in-One

author: Junnn


value: bastianplsfix

value:
I use Tailwind with React and kept copying the same tiny pattern across projects: a cn helper (clsx + tailwind-merge) and a typed Record lookup for variant classes.
Eventually I put it in a package so I'd stop repeating myself. It exports cn and variants, a function that takes a map of variant name to classes and returns a typed lookup. Compound variants are just conditionals inside cn().
It doesn't try to replace cva or tailwind-variants. Those are great if you need defaultVariants, slots, or responsive variants. This is just the subset I actually reach for in practice.
Happy to hear what others think or if I'm missing something obvious.

value: Show HN: cn-variants – Tailwind CSS variants in 3 lines of code

author: bastianplsfix


value: boudra

value:
Hey HN, I built Paseo because i kept SSHing into tmux from my phone to check on agents while on walks, it worked but the UX was rough. I started building a voice-only app for agents but after dogfooding and iterating for months I ended up with this.
Both Anthropic and OpenAI are working on versions of this but I didn't like them and I didn't want to be locked into their respective models.
Paseo takes a different approach: a daemon runs on your machine and you connect to it from any device. your code never leaves your machine.
- Works with Claude Code, Codex, and OpenCode, just launches their CLIs and uses your subs
- Voice mode for dictating tasks hands-free, not perfect but it works
- Manage agents in isolated git worktrees, review diffs, ship from the app
- Terminal support so you don't have to SSH separately
- Connect to multiple machines, see all your agents in one place. I run Paseo in a Hetzner VM for when my laptop is closed.
- Optional E2E encrypted relay for remote access
- iOS, Android, Mac, Windows, Linux, web, and CLI
It’s free and open source (AGPL). No accounts, no tracking.
The name means "stroll" in Spanish, which is basically the use case.
github: https://github.com/getpaseo/paseo
homepage: https://paseo.sh

value: Show HN: Paseo – Run coding agents from your phone, desktop, or terminal (FOSS)

author: boudra


value: jaumapv

value:
A few months ago, I launched my first SaaS. It was a great experience, but checking my metrics every morning quickly became a pain. I hated having to log into Stripe, Supabase, PostHog, etc., in separate tabs just to see how things were doing.
Since nothing out there felt fast or looked good, I ended up building my own iOS app to pull it all into one place. Today I’m putting it out there. It’s called Axiom.
Here is what’s working right now:
Payments: Stripe, RevenueCat, Lemon Squeezy.
Analytics: PostHog, Plausible.
Database: Supabase.
I also built in a feature to generate clean, shareable metric cards in case you like to post your numbers on X or for "Build in Public" updates.
I’m thinking about adding Shopify, Paddle, or Google Ads next, but I want to see what people actually need first.
I’d love to get your brutal feedback, or hear what integrations would be an absolute must for your stack. Let me know!

value: Show HN: Axiom – A native iOS HUD for your SaaS metrics

author: jaumapv


value: stonecharioteer

value: Our Ebook reading app now supports rich color for coding blocks in EPUBs and PDFs.

value: Show HN: Merrilin.ai – Code blocks in your books, finally

author: stonecharioteer


value: mshipman

value: Gave Perplexity Max a single task: predict CFPB enforcement actions from public complaint data. Told it nothing about BoTorch — it found the repo, chose MixedSingleTaskGP, ran 48 BO vs 48 random evals. BO mean F1=0.725 vs 0.389. Total cost: $200. The model is now scoring live companies. Happy to answer questions about the methodology or the BO search space design.

value: Show HN: AI agent autonomously used BoTorch to predict CFPB enforcement actions

author: mshipman


value: gskm

value: Show HN: HighSNR – Cut length and noise from your LLM context

author: gskm


value: rwiteshbera

value: Show HN: DataCia – The database client that lets you focus

author: rwiteshbera


value: ludovicianul

value: Show HN: HiLo – A word guessing game based on binary search

author: ludovicianul


value: gshreyan

value:
Claude Code has no code intelligence for Svelte files out of the box. This plugin registers svelte-language-server as the LSP handler for .svelte files, giving Claude hover docs, go-to-definition, find references, document symbols, and diagnostics.
Install: npx svelte-lsp-claude
MIT licensed, open source.

value: Show HN: Claude Code plugin that gives .svelte files full LSP intelligence

author: gshreyan


value: wilhart

value:
This is my small personal sandbox where I experiment with Linux, self-hosting, and generative AI tools. I use this space to test new ideas and different setups on my VPS.

    Recently, I’ve been focusing on AI-generated video and visual art. I’ve put a lot of work into these experiments, so please don't just hit and run!

I’d love for you to go through the AI stuff I’ve made and let me know what you think.
Feedback or ideas for new experiments are more than welcome.

value: Show HN: Kaoslabs – My Linux VPS sandbox for self-hosting and AI art/video

author: wilhart


value: genedai

value:
Hey HN,
We’re building OpenJobs AI, an AI recruiting agent focused on the outbound sourcing workflow.
In recruiting, teams often already know what kind of person they want — but still spend a lot of time manually searching, filtering, and writing first-touch outreach. We wanted to see how much of that work an agent could actually take over.
Today, OpenJobs AI focuses on the sourcing part of recruiting. Given a role, it can help with candidate discovery, filtering, matching, and outreach initiation. The goal is to move sourcing from a manual, repetitive workflow into something an agent can execute continuously.
We’re now extending the product into the next parts of the recruiting flow, including interview scheduling and automated assessment, with the longer-term goal of building a full-cycle recruiting agent.
Under the hood, the system separates job understanding, search, outreach, and monitoring into distinct components so the workflow can be coordinated reliably across steps.
We’re currently focused on teams hiring internationally, and the product is in beta with generous free trial credits:
https://www.openjobs-ai.com/
We also open-sourced part of the people/talent capability layer behind this work as People Skills — tooling for AI agents that need to work with people-related data, such as understanding talent profiles, matching opportunities, and connecting people to roles:
https://github.com/OpenJobsAI/openjobs-openclaw-skills
Happy to discuss the recruiting workflow, agent architecture, evaluation, or anything around recruiting automation.

value: Show HN: OpenJobs AI – An AI agent for outbound recruiting and sourcing

author: genedai


value: Show HN: Frontpage – LLM-powered news aggregator


value: nicolaib

value:
Hey HN, Nicolai here, co-founder of Rhesis AI.
Most eval frameworks were designed when LLM inputs were text strings. That assumption breaks fast once your AI agent handles boarding passes, invoices, audio recordings or support screenshots. Text-only test cases become workarounds.
So we added multimodal support to Rhesis: attach a file to a test case, run it, evaluate the response. Simple on the surface. Two non-obvious problems underneath.
Normalizing file delivery across endpoints:
Rhesis sends test cases to application endpoints, not directly to LLM providers. Applications implement file handling very differently: base64, URLs, multipart form data, varying MIME type support. We built an abstraction layer that normalizes this without breaking existing integrations.
Handling files across three platform contexts:
A file attached to a test case needs to work in simulation, in the review UI, and in trace rendering. Each context fetches, stores, and renders files differently. Getting that seamless took more wiring than expected.
One thing worth flagging for voice agent builders
Full voice support introduces an extra evaluation layer that image and document evals don't have. Once you add STT or TTS to the pipeline, you're evaluating two things: the transcription layer and the agent response. Most eval frameworks collapse those. We're still working out how to surface that separation cleanly. Curious if anyone here has dealt with it.
MIT licensed. You can try it at app.rhesis.ai or dig into the implementation on GitHub: https://github.com/rhesis-ai/rhesis | Short feature demo: https://youtu.be/odq3GW5qspY

value: Show HN: Rhesis AI - Multimodal test cases for agentic evals

author: nicolaib


value: chamaru

value: Show HN: Donely – Managed OpenClaw hosting, deploy in under a minute

author: chamaru


value: yuvrajangads

value:
I built a CLI that detects patterns AI coding tools leave behind: empty catch blocks, hardcoded secrets, as any everywhere, comments that restate the code, god functions, SQL concatenation.
24 rules across JS/TS and Python. Zero config, runs offline, regex-based so it's fast.

  npx @yuvrajangadsingh/vibecheck .

Also ships as a GitHub Action for inline PR annotations and standalone binaries (no Node required).
Why: CodeRabbit found AI-generated PRs have 1.7x more issues than human PRs. Veracode says 45% of AI code samples have security vulnerabilities. "Vibe coding" is everywhere now but nobody's linting for the patterns it produces.
This isn't a replacement for ESLint. It catches things ESLint doesn't look for, like catch blocks that only console.error without rethrowing, bare except: pass in Python, or mutable default arguments.

value: Show HN: Vibecheck – lint for AI-generated code smells (JS/TS/Python)

author: yuvrajangads


value: quasimo

value: Show HN: SiteMon – Browser extension that monitors your websites

author: quasimo


value:
I've long held a bit of nostalgia for the old PlayStation game Monster Rancher.
You could "discover" monsters by popping in any arbitrary CD in your house – music, a PS game, a PC game, whatever – and it would generate a monster based on the disc's metadata, and add it to your ranch. It was a game about collecting, breeding, and battling these monsters.
The generated monster usually had nothing at all to do with the disc's content, of course. There were some specific discs that were hard-coded in that would give you a relevant monster, but not a ton.
It was a fairly niche thing, though, and the death of CDs sort of killed the whole idea.
But now in the age of LLMs, it feels like maybe the time has come back around for something like this to be pretty fun again, so I've implemented it as an Agent Skill that:
1. accepts a URL and reads the content (or any input, really)
2. follows some standard guidance on generating monster JSON for it
3. uses a Gemini image model to generate a monster avatar
4. renders it all in a fun little trading card image
5. allows you to breed them into hybrids, battle them, and share them to Github Gists
This was mainly a scratch-my-own-itch nostalgia indulgence. I briefly considered doing this as a full blown site, but agent skills give a fair bit more interactive flexibility while not costing me a dime. You can just point your agent (Claude Code, etc) to aiwebb/llmonster-rancher and tell it to get going.
Hope y'all have fun with it.

value: Show HN: LLMonster Rancher

title: Show HN: LLMonster Rancher


value: davidchua

value:
Hey HN,
A few years ago I came across the On the Metal podcast episode with Kenneth Finnegan about setting up the Fremont Cabal Internet Exchange. It sent me down a rabbit hole I haven’t climbed out of.
I'm a software and systems engineer by background, and I am not a network engineer. I’d dabbled with DNS and mail servers before, but always wondered how everything actually tied together at the infrastructure level.
Kenneth’s interview awoke something in me. I went all in, taught myself BGP, figured out how ASNs work, got my own IP prefix and eventually racked my own servers at a local datacenter here in Singapore.
TheLittleHost came out of that. A small DNS hosting service built on infrastructure I fully own, with an Anycast network now spanning Singapore, Tokyo, New Jersey, Los Angeles, and Frankfurt.
I built it because I wanted to run the DNS host I always wanted. One without ecosystem lock-in, that comes with a basic API that CLIs can plug into and have the ability to quickly import and export your zones and records in standard BIND format.
Right now it supports most major standard record types (RFC 1035) including HTTPS and TLSA, TTLs as low as 5s, a REST API, and full zone import/export. Free-tier is just a single zone and signup is just an email and password.
Honestly, it’s not the most feature-rich DNS host out there and I am not trying to be one. I wanted to focus on doing one thing well and owning the full stack than to add on features I cannot stand behind.
DNS is the first primitive I am working on. I’m building towards a more composable infrastructure stack for example, CDN on your own hardware, load-balancing and more. The focus is on keeping things open: no black boxes, no lock-in and on infrastructure you actually own.
It's small by design and I want to keep it that way. Posting here to get some feedback, share my journey, and hopefully inspire a few people to get their hands into Internet infrastructure, the same way others inspired me.
https://www.thelittlehost.com/dns

value: Show HN: TheLittleHost – DNS hosting built on my own ASN and Anycast network

author: davidchua


value: prohobo

value:
I've been working on this desktop tool (FSL license, free for commercial use) for the past month because I now spend more time in a terminal prompting Claude Code instead of using a code editor. It generally works quite well if I ask the right questions, but I still often find a lot of dead code, stubs, or poor architectural choices when I finish a session, and understanding the codebase itself can be jarring after making major changes through vibecoding.
The idea for Scryer is to provide a visual surface using C4 model diagrams to share with an AI so that we both understand the actual state of a codebase, and how proposed changes would affect it. It's basically model-driven development (like UML) but adapted for the LLM era. Because of that, I think using opinionated C4 (https://c4model.com/) is the best approach:
- It's simple enough to understand without putting the developer into a coma
- There's just enough context to guide the AI coherently
- Doesn't try to replace code, but defines structural guardrails and scope
Also, I've included some newer agent-oriented methodologies like "always/ask/never" contracts (which have turned out to be very useful), task decomposition, MCP + ACP connections, etc.
This is very experimental and early, so it's quite rough around the edges, but I'm already using it in my own dev workflow and I hope you guys check it out. I honestly think this might be the year of MDE/MDD - as we abstract away the code layer, software architecture fundamentals are becoming more important than ever.

value: Show HN: Scryer – Visual architecture modeling for AI agents

author: prohobo


value: Show HN: Hackerbrief – Top posts on Hacker News summarized daily


value: loichrn

value:
I’ve been building an open-source backup CLI in Go:
https://github.com/Cloudstic/cli
Docs:
https://docs.cloudstic.com
Features:

  - encrypted backups
  - content-addressed deduplication
  - local / S3 / B2 / SFTP storage
  - local / Google Drive / OneDrive / SFTP sources
  - restore to ZIP or directory

One thing I wanted to get right was portable drives. If the same external SSD moves between machines, the tool uses its GPT partition UUID to keep the backup history tied to the drive itself, instead of treating every new mount path as a different source.
Recent posts:

  - https://blog.cloudstic.com/2026/03/12/backing-up-portable-drives/
  - https://blog.cloudstic.com/2026/03/16/practical-backups-with-cloudstic-profiles/

Would love feedback

value: Show HN: Open-source encrypted backup CLI

author: loichrn


value: kwhandy

value:
i built this because i’ve been experimenting with MCP and felt there was a need lightweight version for ecosystem.
most existing clients felt a bit too noisy and bundled into larger ecosystems, so i wanted simplest/ near plain version that just focuses on end-user chat experience.
stack(main): NextJS(App Router) + Vercel AI SDK
capabilities:
+ set single MCP endpoint and brand mode(bring your own brand asset) on ENV
+ prepare local db or external endpoint(SQLite, PostgreSQL, MySQL)
+ choose in-memory(default) or external/ local Redis endpoint
+ built-in auth via Better Auth & Resend(optional)
+ support file upload with Cloudflare R2
+ support location-sharing with LeafletJS and Browser Geolocation or Google Maps Platform
+ automatic data cleanup with Trigger(free-tier trigger.dev is ENOUGH)
+ auto-detect user location so they dont need to set timezone manually
+ locale currently support 10 languages(EN, ID, KR, JP, ES, ZH, DE, NL, FR, IT)
+ plain/minimalist interface
+ install with single interactive script(you will prompted to fill ENV) via command line
+ ready to deploy manual(assume Docker), Dokku, Render, and Fly
+ open-source with some restriction only for other hosting/ consulting business(personal/ org who charge people anything as exhange)
im looking for feedback on the implementation and codebase, especially from anyone else building MCP, frontend developer, and security.
checkout repo: https://github.com/repaera/chat

value: Show HN: Chat – Another open-source chat UI for MCP Server

author: kwhandy


value: bvi

value:
I grew up in Singapore, spent a decade in the US, now live in Canada. Family spread across multiple countries - I'm sure it's a typical story for several (most?) of the folks here.
My dad passed suddenly in 2024, when he was traveling with my mom. This was my biggest nightmare growing up, when I first moved half the world away from my family in my teens...the one thing that jolts you awake at night ("...what if something happens to my parents and I'm not there?"), and it actually happened to me. My siblings and I had to scramble and get to Singapore asap to support my mom, manage all the procedures, gather all types of documents, figure out which accounts he had access to, talk to numerous banks/institutions, lawyers etc etc etc. It was overwhelming to deal with all this (and this was in Singapore, which tends to be very efficient!) while also having to deal with the grief of losing my dad. I wouldn't wish this experience on anyone, but unfortunately, death is the one thing we will all have to deal with, like it or not.
That said, what made it slightly easier for us was that my dad was - thankfully! - a very organized man. He'd prepared everything for us...kept a detailed spreadsheet with account details, instructions. So we had quick access to nearly everything to help the legalities, just because he had maintained something like this over the years. He knew the day would come, and made sure we didn't have to struggle to find this stuff.
Legal stuff aside, I was acutely aware that I didn't have enough of the 'personal' aspect to this beyond some photos and videos. My older son was not even 2 years old when my dad passed...and my younger son was born just 2 months after. They won't have any memories of their grandpa. What I would do to go back in time...and ask my dad, "hey, do you have any words of advice for the grandson you won't get to see? Anything you'd like them to hear, directly from you, years down the road? Any advice for me??"
I built Snippets to make it easy to preserve what matters for the people you love - voice notes, stories, critical documents, messages in any language - without needing to be organized or tech-savvy to do it.
The core problem: people know they should preserve things for their family, but they freeze. What do I say? How do I organize it? What if my parents only speak [Tamil | Chinese | French | Arabic | etc]...and my kids speak English?
What makes Snippets different:
- AI life story interview: instead of staring at a blank screen, the AI asks you thoughtful questions about your life, listens in any language, and turns your spoken answers into written stories (or "snippets") automatically. Your parents just talk. That's it.
- 50+ language transcription and translation: record in English, French, Tamil, Mandarin, Arabic, Hindi, Tagalog, whatever is natural. Recipients get it translated to English. Bridges the generational language gap that diaspora families deal with constantly.
- Scheduled and legacy delivery: set a message for your daughter's 18th birthday, or have it delivered automatically if you're no longer around. Trusted contact verification with multiple check-ins and a long grace period so nothing gets delivered prematurely.
- Document vault: securely upload documents and policies and forward important emails to organize the practical stuff your family will need.
Built in ~5 weeks using Claude. Stack: React, TypeScript, Supabase, Vercel, Stripe, Resend, Deepgram + Whisper.
Works on any device, no app install needed. Free tier too so you can get a good feel of Snippets.
I'd love your thoughts.
https://mysnippets.com

value: Show HN: Snippets – AI-first legacy app: Record messages, deliver years later

author: bvi


value:
Hi HN,
I built TruthLens, an AI-powered platform that analyzes the credibility of news articles.
The platform aggregates news from 130+ global sources and uses AI to:
• extract key claims
• evaluate credibility signals
• analyze source trust
• detect sensational language
• highlight potential misinformation
Each article receives a credibility score and an AI explanation of why it may or may not be reliable.
Users can also explore trending stories, vote on credibility, and submit news articles for analysis.
I built this as a solo project and would love feedback from the HN community.
Demo:
https://truthlens-ai.replit.app

value: Show HN: TruthLens – AI that analyzes the credibility of news articles


value: marquisdegeek

value:
A ZX81 emulator, written for the Dragon, running in the Xroar emulator, running on my PC.
It handles just enough to run a game of 1K Chess, by David Horne. (Details on https://en.wikipedia.org/wiki/1K_ZX_C...)

value: Show HN: Retro inception – an 8-bit computer emulating another 8-bit computer [video]

author: marquisdegeek


value: loopology

value:
Gmail is shutting down its POP-based mail fetching feature later this year. If your mail lives on a server you can SSH into, here's a simple replacement: a procmail recipe pipes each incoming message to a small Python script that uploads it to Gmail via IMAP.
No polling, no cron jobs - mail arrives in Gmail the moment it hits the server.
https://nosuch.biz/mailsync/
Code: https://github.com/bwagner/gmailsync

value: Show HN: Gmail killing mail fetch – procmail and IMAP replacement

author: loopology


value: Show HN: Sprinklz.io – An RSS reader with powerful algorithmic controls


value: aveandrian

value:
Hi HN — I’m building Padelio, a platform to run padel tournaments and leagues without the usual admin chaos.
Most organizers still do everything in WhatsApp + spreadsheets: player signups, pairing logic, score tracking, standings updates. It works at 8 players and breaks at 30.
So we built Padelio to make organizers look superhuman:
launch a tournament/league fast
auto-generate matches and standings
onboard players via join code or QR
run live scoring on web and mobile
support Americano, Mexicano, King of the Court, and recurring seasons
What makes us different: we optimize for recurring communities, not one-off events.
If you run local sports communities, I’d love brutal feedback on:
Which feature would make this a must-have for your group?
What would block you from switching from spreadsheets tomorrow?

value: Show HN: Padelio – run padel tournaments and leagues without spreadsheets

author: aveandrian


value: pitchinnate

value: Show HN: On-demand session replay triggered by a magic link for support teams

author: pitchinnate


value: surprisetalk

value:
Howdy
My name is Taylor (https://taylor.town), and I'm hosting a nerdy writing contest with my friends at Quarter Mile (https://quarter--mile.com).
Here's the premise:
The aliens are coming. They asked us for just one item: a written document from humanity. We have no idea what the document should be, so we're asking you. Please physically mail submissions in your writing before May 15, 2026.
Learn more:
https://www.dearaliens.net

value: Show HN: Dear Aliens

author: surprisetalk

title: Show HN: Dear Aliens


value: vtemian

value: Show HN: Real-Time Observability for Cursor/Claude Code/Codex/OpenCode Agents

author: vtemian


value:
MCP gives AI agents access to real tools — databases, filesystems, APIs. There's no built-in way to say "require human approval before any write" or "this tool is never allowed, ever."
Cordon is a stdio proxy that sits between Claude Desktop and your MCP servers. Every tool call flows through a policy engine before it reaches the upstream server.
Policies per server or per tool: allow, block, approve, approve-writes, read-only, log-only. Write detection by tool name prefix — drop_table gets caught, read_data passes through automatically.
When a tool call needs approval, Cordon pauses and prompts in the terminal. For teams, it can route approvals to a Slack channel instead — the agent waits, a human clicks Approve or Deny, the call continues or gets blocked.
One config file:
export default defineConfig({
  servers: [{
    name: 'db',
    command: 'npx', args: ['-y', '@my-org/db-mcp'],
    policy: 'approve-writes',
    tools: { drop_table: { action: 'block' } },
  }],
  audit: { enabled: true, output: 'file' },
  approvals: { channel: 'terminal' },
});
npx cordon-cli init # patches Claude Desktop config automatically
npx cordon-cli start
Every tool call is logged to a structured audit trail. If you want a hosted dashboard with a live event viewer and team API key management, there's a free hosted option at https://cordon-server-production.up.railway.app/dashboard/ — but the CLI works entirely standalone.
Repo: github.com/marras0914/cordon

value: Show HN: Cordon – open-source security gateway for MCP tool calls


value: erikmat

value:
Most job seekers refresh LinkedIn and Indeed. That's exactly the problem, those jobs have 300 applicants by morning.
DevJobAlerts monitors company ATS platforms directly (Greenhouse, Lever, Workday, ...). Jobs posted there often sit for days with a fraction of the competition before they ever get to the major boards. We email you when they appear, matched to your tech stack and location.
Stack: Django + Celery + PostgreSQL. Emails via Resend.
Signup required to try it - the core value is getting the email, hard to demo otherwise. First alert comes within minutes; after that, hourly or daily depending on your plan.
Curious whether keyword packs ("Python developer", "frontend engineer") are the right abstraction or if free-form queries would work better.
https://devjobalerts.io

value: Show HN: DevJobAlerts – Email alerts for dev jobs from boards nobody's watching

author: erikmat


value: Show HN: Mt – knowledge manager meets spaced repetition


value: soexya

value:
I've been experimenting with making typing practice feel more like a game.
Kwerty is a small browser typing arena with:
- rush mode
- survival mode
- themed word packs like tech and code
- combo scoring based on accuracy
It’s meant to be something you play for a minute or two between tasks.
Would love feedback on gameplay, difficulty, or ideas for new modes.

value: Show HN: I made a typing game where mistakes can kill your run

author: soexya


value: arcadianalpaca

value:
Hi HN! After 15 years as an iPhone user, I recently switched to Android. What I missed the most after switching was my old audiobook player, and I couldn't find one I liked, so I decided to build one.
It's called Earleaf, and lets you play your local audibook files.
The feature I'm most excited about is Page Sync. You take a photo of a page in your physical book (or e-book) and the app finds that position in the audiobook and jumps to it. It works by transcribing the book on-device, and when you take a photo, it uses ML Kit to do the OCR scanning, and matches the text against the transcription. The initial transcription takes a while, but that's a one-time thing, and when it's in place, the actual search takes about two seconds on my device. And everything runs locally.
Beyond that, it's a full-featured player: nested collections, independent listen-through tracking, statistics, per-book playback speed where every time display adjusts. No account, no internet required, no ads.
Happy to answer questions about the app and its features!

value: Show HN: Earleaf – An audiobook player that syncs with your physical book

author: arcadianalpaca


value: eibrahim

value:
ChatSpark is a lightweight, embeddable live chat widget for solopreneurs and small business owners who handle support themselves.
Single script tag embed. One dashboard. Real-time messaging via WebSocket. Email/push notifications. Offline mode with leave-a-message form. Optional AI auto-replies from your FAQ content.
Built with Next.js, Node.js, WebSocket, PostgreSQL. Deployed on Kubernetes.
Free tier: 1 widget, 50 conversations/month. Pro: $12/mo. Business: $29/mo with AI replies.
The main design constraint was simplicity. No multi-agent routing, no ticket systems, no onboarding wizard. Paste one script tag, start chatting.
Honest limitations: it's single-operator only, no team features. If you have more than one support person, this isn't the right tool. It's specifically for the "I do everything myself" crowd.
https://www.chatspark.dev

value: Show HN: ChatSpark – Live chat widget for solo operators

author: eibrahim


value: mmayberry

value:
Hi HN,
After shutting down my YC startup late last year , I’ve been spending some time rebuilding my product and engineering muscles by revisiting old ideas in my notebooks.
This is one of them:  https://www.personalcolorai.com
The idea came from a trip to Korea where “personal color analysis” is very popular but usually costs $200–$300 per session. I wondered if it was possible to approximate something similar using the latest AI tools and a simple selfie.
The site lets you upload a photo and it returns:
• your Korean color season
• a few colors from your palette
• a celebrity “color twin” (both Korean and US)
To be clear, this is not technically groundbreaking.  I have not created anything new or novel and I am fully aware this is as far from impressive as possible. It was mostly an excuse to get familiar with some newer tools and force myself to ship something small instead of endlessly tinkering.  I have always been on the Ops/Sales/Marketing side of startups and wanted to try something on the product side :)
If anyone here takes a look, I’d really appreciate feedback. HN is usually very good at quickly identifying the weak spots in a project.
Thanks for checking it out and please let me know if you have any feedback or questions.

value: Show HN: PersonalColorAI – From selfie to full color analysis in 60 seconds

author: mmayberry


value: rhodey

value: Hecate is an AI you can voice and video call from Signal iOS and Android. This works by installing Signal into an Android emulator and controlling the virtual camera and microphone. Tinfoil.sh is used for private inference.

value: Show HN: Hecate – Call an AI from Signal

author: rhodey


value: ecstaticpirate

value:
karpathy's autoresearch runs an AI agent in a loop: modify one file, measure one metric, keep or discard, git checkpoint, repeat. you sleep, it runs 100 experiments overnight.
the thing that stuck with me wasn't the ML application - it was why the loop is safe to run unattended. four constraints: one file (bounded scope), one metric (deterministic decision), time-boxed experiments (can't get lost), git checkpoint (always reversible). remove any one and you need supervision. keep all four and you can walk away.
i realized the same pattern works for debugging.
the normal way you debug a silent failure: fix the first thing that looks wrong, discover it wasn't the real cause, fix the next layer, repeat. hours chasing symptoms without reaching the bottom.
so i built two claude code skills that apply karpathy's loop to bug fixing:
/rootcause - autonomous diagnosis. describe a symptom ("pipeline processed 1000 photos, found zero faces, no error"). it generates hypotheses ranked by probability, investigates the most likely one, confirms or eliminates it, narrows, repeats. max 10 rounds. read-only - never touches your code. i pointed it at a face detection bug. six rounds, found a timeout silently killing the process. i didn't read a single file myself.
/autofix - autonomous fix-and-verify. takes a root cause, designs a fix, writes validation tests before the fix (so the tests stay honest), applies it, runs the tests. if they fail, it re-diagnoses and tries a different approach. max 3 cycles. all on a temporary git branch - if nothing works, your code is exactly where it was.
they chain: rootcause finds the problem, autofix ships the fix. describe a symptom, walk away, come back to a verified fix or a clear report of what was tried.
the constraints are the feature. one change at a time, one metric, git as the undo button. the agent has a narrow lane and a clear feedback signal - that's what makes it safe to run without watching.
open-sourcing both:
/rootcause: https://github.com/ecstatic-pirate/rootcause
/autofix: https://github.com/ecstatic-pirate/autofix
copy SKILL.md to ~/.claude/skills/{name}/SKILL.md and they work as slash commands.

value: Show HN: Karpathy's autoresearch applied to debugging – two open-source skills

author: ecstaticpirate


value: fabriciosx

value:
Hey HN,
I built Git Quest, it reads your public GitHub history and turns it into
an idle RPG character.
How it works:
- Your most-used language determines your class (TypeScript → Paladin,
  Python → Sage, etc.)
- Commits generate Power and XP
- Your character auto-battles dungeons while you code – no active play needed
- Enemies drop loot across 5 rarity tiers
- Live leaderboard ranks developers
It only reads public GitHub data.
I built it because I wanted something that rewards coding consistency
without being another "streak" tracker. The idle mechanic means prolific
coders naturally progress faster, but you don't have to babysit it.
Would love feedback on the game loop and whether the class/language mapping
feels right.
https://www.gitquest.dev

value: Show HN: Git Quest – I turned your GitHub commit history into an idle RPG

author: fabriciosx


value: davemelk

value:
Hi HN,
We built Themal, a small component for React that adds a design system editor to an existing web app.
The goal was to make it easier for teams to customize UI colors without accidentally breaking accessibility. When a user selects colors, the editor automatically enforces WCAG AA contrast requirements.
One feature we found useful is the ability to extract a color palette from an image. Upload or select an image and Themal generates colors for brand, secondary, accent, background, and foreground that can be applied directly to the design system.
Some design choices:
Writes CSS custom properties, so it works with any framework that reads them
Includes a built-in contrast auditor (~2KB) instead of relying on large libraries like axe-core (~580KB)
Uses scoped styles, so it does not affect the host application's CSS
Typography inherits from the host page
Can export results as CSS, design tokens, or a GitHub pull request
Design goals were to keep it simple:
No runtime dependencies beyond React
No vendor lock-in. Everything is just CSS variables
A web component version that works without a build step
Install:
npm install @themal/editor
The README also includes an AI scaffold prompt that generates integration code for your stack.
Interested to hear how others approach accessible customization in design systems.

value: Show HN: Themal – a React design system editor plugin with WCAG contrast auditor

author: davemelk


value: Looking forward to your feedback!

value: Show HN: Effect-log – Stop AI agents from sending the same email twice

story_text: Looking forward to your feedback!


value: MaxMussio

value: Show HN: High Output Software Engineering (Book)

author: MaxMussio


value: akadeb

value:
Hi HN! I built an open-source framework for local AI toys.
With a <$10 ESP32 device and a Mac running Apple Silicon, the toy can have real-time conversations without sending any audio or text to the cloud.
The project supports voice cloning, multilingual conversations (10 languages), and runs fully locally using Whisper + MLX VLMs and Qwen3-TTS and Chatterbox-Turbo.

value: Show HN: Build a $10 AI Toy that runs locally on your Mac

author: akadeb


value: delaneythompson

value:
Hey HN,
I'm Delaney, one of the founder of Caddie AI, a Slack bot with access to my Gmail, CRM, LinkedIn, calendar, and 90+ other tools.
The origin: I ran a hiring marketplace that did $100k in 8 months. The GTM work was relentless - logging notes to the CRM after calls, prepping for meetings by hunting through old emails, drafting outreach, following up with leads. Same 5-10 tasks every single day. So I started building an agent to handle it.
The first version worked, but only for me. My co-founder isn't technical and explaining how to configure an agent was its own project. Which tools to connect, how to write system prompts, what MCP even is. She's sharp, just had no reason to care about any of that. I kept trying to hand it off and kept failing. Eventually I stopped explaining and just rebuilt it so there was nothing to explain.
That version is what we're launching now. We built it for ourselves, used it to run all of our own GTM - outreach, CRM logging, meeting prep, Reddit/X research + automation, LinkedIn ghostwriting content, candidate pipeline tracking - and when we saw how much time it was saving us, the product became obvious so we're bringing it to market.
Here's how it works technically:
- Installs via Slack App Directory (60 seconds, OAuth)
- MCP connects 100+ tools as callable functions - Gmail, LinkedIn, HubSpot, Attio, Google Calendar, Sheets, Reddit, Twitter, and more
- A "skills" system lets you install pre-built workflows (morning standup, CRM note logger, LinkedIn ghostwriter, cold email drafter) or write your own with a plain English prompt
- It persists a rules file per user - tell it your preferences once ("always lead with ROI in cold outreach, I work in CST") and it applies them automatically going forward
- All write actions (send email, publish post, log to CRM) require explicit confirmation before executing
The design bet: most people won't configure a standalone agent tool. But if the agent is already where they work (Slack) and it just works the first time they type something, the activation problem goes away.
We're an official Slack partner and launched this week. About 50 users in free beta.
A genuine question for the thread: we default to "show draft, get confirmation" for all write actions. A few power users want to flip this off and let the agent just fire. What's the right default - safe-by-default or assume-trust? Curious how others have thought about the autonomy tradeoff.
https://caddieagent.ai

value: Show HN: Caddie – AI agent that lives in Slack, executes tasks across your tools

author: delaneythompson


value: zhangdawei

value: Show HN: I built Formax to explore how Claude Code-style assistants work

author: zhangdawei


value: jotafi

value:
Hi HN, I'm Riccardo. I've been running Proxmox in production for years. The web UI is fine, but every time I tried to automate VM provisioning — Terraform, CI pipelines, scripting — I hit the same walls: an API that's an afterthought, mutable Debian hosts that drift, Perl internals nobody wants to debug.
So I started building kcore. It's a virtualization platform where the gRPC API is the primary interface. VMs are defined in YAML and applied declaratively. The host OS is NixOS — immutable, atomic updates, instant rollback. The control plane is written in Go.
It's alpha. No HA, no live migration, no web UI yet. But the foundation is solid and the code is on GitHub: https://github.com/rtacconi/kcore
I'd love feedback from anyone who's fought Proxmox's API or run bare-metal Kubernetes. What would you want from a modern hypervisor?

value: Show HN: Kcore – A modern, API-first virtualization platform built on NixOS

author: jotafi


value: jacomoRodriguez

value:
Hey, I’m Mario. After chatting with a colleague about how AI agents are changing dev work, we got stuck on a question: Why share code when prompts can generate it on demand?
I wanted to explore this further, so I build "Open Prompt Hub" — think GitHub, but for prompts: https://openprompthub.io
How it Works:
Instead of shipping binaries or source code, you share instructions and specs in form of a prompt. You can take this prompt, paste it into their agent or IDE and watch it build. If it’s not a perfect fit? Fork it, tweak it, and generate your custom version.
All meta infos like version, description, test cases etc. are stored in a frontmatter block at the start of the prompt. So it's one file containing all the infos you need. (https://openprompthub.io/docs)
Features of the platform:
- Versioned prompts with infos which models to best use
- Forking for customization
- Security Scans: prompts are scanned for security issues and prompt injections.
- User can give feedback, if the prompt successfully build what was promissed (scoped on models, so you know which one to best use for execution)
- Flagging mechanism
It’s an MVP, but the core features—versioning, model-specific build status, and security scanning — are live.
I'm currently looking into further features, such as:
- a git-like cli for publishing prompts and downloading/piping them directly to your agent
- multi stage/file prompts for more complex applications
- configurable prompts for e.g. switching programming languages, features, etc.
- better spec and test definition for build verification
I’d love your feedback... on the idea, the spec and the platform.

value: Show HN: Open Prompt Hub – Don't share code, share intent

author: jacomoRodriguez


value: alexanderbz

value:
Hi! I built Status Update as an experiment to see if Claude Code's session traces contained enough signal to write your standup for you, without any manual input. Turns out they do a pretty good job.
Quick path to a result:
- Inside any Claude Code project, run: `/plugin marketplace add AlexanderBZ/claude-status-update`
- Then: `/plugin install status-update`
- Then: `/status-update:generate`
You'll get a short exec summary followed by your work categorized into Bugs, Features, and Other, scoped to the last 24 hours of that project.
The Stack:
- A Python CLI reads `~/.claude/projects/[current-project]/*.jsonl` and extracts user messages and AskUserQuestion responses as intent signals. No LLM involved in this step, it's fully deterministic.
- Claude reads the grouped signals, collapses each session into a work item, classifies it, and writes the exec summary.
- Everything runs locally. The scratch file written during processing is deleted after Claude reads it.
This isn't a replacement for writing good commit messages or keeping a work log. It's a last-mile tool for the gap between "I know what I did" and "I need to say it out loud in 60 seconds." It works best when you use plan mode or write messages describing intent. Silent sessions won't produce much.
Currently in early release. Any feedback on or tips on how to approve it are greatly appreciated!
Source (MIT): https://github.com/AlexanderBZ/claude-status-update

value: Show HN: Generate Automatic Standup Updates from Claude Code

author: alexanderbz


value: jdbiggs

value: Show HN: ParrotPod – Automatically generate a custom news podcast every morning

author: jdbiggs


value: Horos

value:
glp traces data flows across function boundaries in Go programs.
Standard Go tools (go vet, staticcheck, gopls) analyze one package at a time.
glp loads the entire program into SSA, builds a VTA callgraph that resolves interface dispatch and closures, then walks it.
The core is a 217-line recursive DFS that follows a tainted value through SSA instructions, jumping across functions via the VTA callgraph.
Four jump cases: Call (args→params via VTA), MakeClosure (bindings→freevars), MakeInterface (interface casts), Store (struct taint poisoning).

  Standard Go tools          glp
  ─────────────────          ───────────────────────
  per-package analysis  →    whole-program SSA
  direct calls only     →    VTA (interfaces + closures)
  no data flow          →    inter-procedural taint DFS
  no sink detection     →    bottom-up from database/sql

  7 MCP tools: load, callgraph (static/VTA), taint, sinks, sql extraction, dead exports, err-check. Runs as an MCP server for Claude Code or any MCP agent. Also usable as a Go library.

Same class of analysis as commercial SAST tools, in 1462 lines with zero deps beyond golang.org/x/tools. Pure Go, CGO_ENABLED=0, MIT.

value: Show HN: GLP – Golang/Golang Inter-procedural taint analysis

author: Horos


value: JonChesterfield

value:
This is clangd extended to give feedback on host and device parts of cuda, including things like syntax errors within inline ptx. Actual cuda as it is written or the clang dialect as you prefer.
I like the tarball release as that's a set of x86 binaries that run as your normal user. There's other good stuff in the package too - it's a complete cuda to amdgpu or nvptx compiler toolchain.
Questions / feedback welcome here or to jon@spectralcompute.com or via https://discord.com/invite/KNpgGbTc38 etc

value: Show HN: Clangd for CUDA Device Code

author: JonChesterfield

title: Show HN: Clangd for CUDA Device Code


value: bogdanmnt

value: Show HN: Asenix – an anthill for coordinating AI research agents

author: bogdanmnt


value: chepy

value: Show HN: Buda – AI agents forming a company (Claws running a startup)

author: chepy


value: elpalek

value: Fully playable on RP2350 with 6 buttons. Fire and select shares the same key.

value: Show HN: I ported DOOM to GitHub Universe 2025 conference badge

author: elpalek


value: Show HN: Arko – Real-time AI threat modelling inside Cursor and VS Code


value: asteinh

value: Show HN: Flashbay – remote access to MCU hw for flashing, serial, and CI/CD

author: asteinh


value: testforge

value:
Hi HN,
I built a tool that generates pytest API tests from an OpenAPI spec.
You can paste an OpenAPI URL and it generates a baseline pytest suite that hits each endpoint.
Live demo:
https://openapi-test-generator.vercel.app/
GitHub:
https://github.com/ryancrandall801/openapi-test-generator

value: Show HN: Generate pytest API tests from an OpenAPI spec

author: testforge


value:
Hi HN,
I'm Maciej, founder of Workflow Builder. Over the last few years our team has been building diagramming and
workflow tools for complex systems (industrial automation, AV system design, financial workflows, etc.).
One thing we repeatedly noticed while working with clients is that many companies did not want to adopt full workflow automation platforms. Tools like Zapier, n8n or Camunda are great when you want an entire automation platform. But many teams we worked with wanted something different.
They already had their own backend systems and orchestration layers. What they were missing was a good UX for designing workflows inside their own products.
The main concerns we kept hearing were:
- lack of ownership over workflow interface
- difficulty embedding external automation platforms into SaaS products
- limited UX customization
- tight coupling between visual editors and execution engines
So instead of building another automation platform, we took a different approach. We separated the workflow modeling layer from the execution layer.
The idea is simple:
Frontend → designs the workflow graph
Backend → executes the workflow
This "frontend-first workflow architecture" allows teams to embed workflow building capabilities directly inside their own software while keeping full control over their backend logic.
We released the visual workflow builder as an open-source Community Edition SDK. It allows developers to embed a customizable workflow editor into their own applications or build a workflow tool upon it.
Some use cases we've seen so far:
- SaaS platforms embedding automation into their product
- domain-specific workflow tools
- AI agent orchestration interfaces
- internal automation tools
Demo: https://workflowbuilder.io
GitHub: https://github.com/synergycodes/workflowbuilder
Curious to hear how others here approach the separation of workflow modeling and workflow execution.

value: Show HN: Open-Source Workflow Builder SDK


value: june-jule

value: Show HN: Governor – Quality gates for AI agents (465 tests, no Deps)

author: june-jule