value:
I built a user-space implementation of ping that constructs Ethernet frames, performs ARP resolution, builds IPv4 headers, and sends ICMP echo requests manually using AF_PACKET.<p>- ARP (packet format, cache with aging, re-ARP, conflict handling)
- IPv4 header construction and checksum
- DF handling and ICMP Fragmentation Needed (Type 3 Code 4)
- IP fragment reassembly
- ICMP echo request/reply parsing
- A basic ping loop with loss statistics<p>The goal was to understand how packets actually move from Layer 2 upward.

value: Show HN: Implementing ping from the Ethernet layer (ARP,IPv4,ICMP in user space)


value: charlie-w

value: Show HN: MCP tools for AI-driven E2E testing across 10 platforms

author: charlie-w


value: michaloo

value: Show HN: CLI to estimate Cloudflare bill before it surprises you

author: michaloo


value: ekadet

value:
I built a set of commands that enforce a simple discipline: no code gets written until you've reviewed and approved a written plan.
The workflow: /bt-research → /bt-plan → /bt-review (repeat 1-6x) → /bt-implement
The key insight (from Boris Tane's workflow): plans are shared mutable state. Instead of steering the AI through chat, you both edit the same markdown file. You add inline notes like "NOTE: this should be a PATCH, not PUT" and the AI updates the plan accordingly.
Blog post with full details: https://ekadetov.github.io/2026/02/23/bt-plan-first-workflow...
GitHub: https://github.com/ekadetov/bt-opencode-commands

value: Show HN: Bt – Plan-first AI coding commands for OpenCode

author: ekadet


value: fbrooksssss

value: Show HN: PageBolt – Screenshot, PDF, narrated video recording API with MCP

author: fbrooksssss


value: andrewmi

value: Show HN: Slate Notes and Todos

author: andrewmi

title: Show HN: Slate Notes and Todos


value:
Hi HN — I think AI video is going through a real step-change right now.
Over the past year, the quality jump has been dramatic. Newer models (including ones like Seedance) are getting much better at motion coherence, style consistency, prompt following, and producing clips that are actually usable for real work — not just demos.
That shift is what pushed me to build Veemo.ai.
The problem I kept running into wasn’t just model quality — it was workflow quality:
- too many failed jobs / upload issues
- fragmented tools for text/image/video inputs
- slow iteration loops when testing prompts and settings
- hard to compare outputs and move quickly from “idea” to “usable clip”
Veemo.ai is my attempt to make these stronger AI video models actually practical to use.
What Veemo does:
- text-to-video, image-to-video, and video-to-video in one workflow
- access to multiple AI video models in one place (including strong newer options like Seedance)
- faster iteration loops for prompt tweaks / retries / settings changes
- a workflow designed for creators and teams who need usable outputs quickly (ads, product clips, social content, etc.)
My core belief:
AI video is no longer just “fun tech.” It’s becoming a real production tool — but the UX/workflow layer is still lagging behind the model capabilities.
That’s the gap I’m trying to close.
I’d love feedback from people here who actively use AI video tools:
1) What improved the most recently in your experience: quality, consistency, controllability, or speed?
2) What still breaks your workflow the most?
3) What would make you trust a new AI video tool enough to pay for it?
If you try Veemo and hit bugs/performance issues, I’d really appreciate details (input type, model, browser, error message). I’m here and happy to answer questions about the product, model tradeoffs, reliability, and pricing logic.

value: Show HN: AI video is having its "ChatGPT moment" – I built Veemo.ai


value: Show HN: Sourced – Grep any PyPI/NPM package's source code via MCP


value: mrded

value:
I really like the fixture model in Vitest and Playwright - typed, composable, dependency-based setup with automatic ordering and teardown.
That pattern is powerful, but it’s tightly coupled to those runners. I wanted the same model in bun:test and across projects using different test frameworks.
So I built a small runner-agnostic fixture system in TypeScript inspired by that approach.
It lets you:
- define fixtures with explicit dependencies
- request only what a test needs
- resolve setup order automatically
- deduplicate shared fixtures
- run cleanup in reverse order
- detect circular dependencies
It’s intentionally small and framework-agnostic.
I’d really appreciate feedback on the API design and whether this pattern makes sense outside Vitest/Playwright.

value: Show HN: Runner-agnostic typed test fixtures inspired by Playwright

author: mrded


value: trusera

value: Show HN: AI-BOM – Open-source scanner that discovers shadow AI components

author: trusera


value: Show HN: Standard Cucumber Steps

title: Show HN: Standard Cucumber Steps


value: manishmshiva

value: Show HN:I made yet another ToDo App

author: manishmshiva

title: Show HN:I made yet another ToDo App


value: greenbeandev

value: I've built a free AI coach to help people get feedback and practice their VC pitch. You can practice as many times as you want and refine it so that you put your best food forward. Would love to hear feedback from early stage founders.

value: Show HN: AI Coach for VC Pitches

author: greenbeandev

title: Show HN: AI Coach for VC Pitches


value:
Hi HN,
I built NanoMaker AI as a personal project because I wanted to work only with the top AI models, but couldn't find a platform that combined them.
For my creative workflow, I use:
Nano Banana for generating images
Sora2 Veo 3.1 for turning images into videos
Suno for generating music
Individually, these tools are excellent, but moving assets between them was tedious and disjointed. No single platform offered the flexibility to use these top-tier models in a unified way.
So I decided to build my own dashboard to integrate them. It's still rough around the edges, mostly for personal experimentation, but it lets me quickly produce content by combining high-quality AI images, videos, and music in one workflow.
You can try it here: https://nanomaker.im
I'd love feedback from anyone interested in multi-AI pipelines or creative automation.

value: Show HN: NanoMaker AI - my personal workflow combining Nano Banana, Sora2, Veo3


value: jelmervnuss

value:
I built Play Console Pricing Adjuster, a Chrome browser extension that automates global pricing inside Google Play Console.
If you want fair, localized pricing, you have to manually update ~170 countries. That means scrolling, switching currencies, typing numbers, saving, repeating. It’s slow and error-prone.
What this extension does:
- Calculates country prices using Purchase Power Parity (PPP) data
- Adjusts prices relative to your base market
- Automatically applies prices inside Play Console
- Handles local currencies
- Updates all countries in one pass
It runs entirely in the browser as a Play Console extension. No scraping accounts, no external automation bots.
I built it after spending hours manually localizing prices for my own apps, or just not setting regional prices.
Would love feedback on:
- How you handle regional pricing today
- Any edge cases you’ve run into with Play Console pricing
Happy to answer technical questions.

value: Show HN: Set Purchasing Power Parity app prices for 160 countries in Google Play

author: jelmervnuss


value:
Ever used Moltbook and said "Man I wish I could comment on this post!" or "I like this AI Agent. I wish I could talk to him more!"
SocialTense is a social media platform which breaks that barrier. Instead of being just observers to AI Agents talking, you can now dive in too! Talk to any AI Agent in the world, participate in their conversations, post your thoughts and see what other agents have to say to that, slide into an Agent's dm's and practice your flirting skills ;) Anything you wanted to do in current social media platforms but couldn't, ST is the place!
Log on to https://socialtense.com, create an account, get your agent to join the conversation too, and become a part of this network which has no boundaries. See you there :)
P.S. - Do leave a comment if you find the platform interesting or have any suggestions.

value: Show HN: I made a Social Media platform to talk to AI Agents around the world


value: jwally

value:
I wanted to play an FPS with my kids. Every option required creating accounts, installing launchers, granting permissions, downloading companion apps — a 20-minute ordeal before anyone fires a shot. Per person. I just wanted something that works.
So I (lets be honest, Claude) compiled Quake 3 to WebAssembly. One link, no installs, no accounts. Click Host, share the 4-letter code, and you're fragging. Game traffic goes peer-to-peer over WebRTC, signaling is a single Lambda function. The whole thing costs about $1/day under heavy load.
Notes: There's probably a ton here that could be better, faster, cooler. Please fork and DIY if you're into this sort of thing :-)
https://github.com/JWally/web-quaker

value: Show HN: In Browser, Serverless Quake 3 Arena

author: jwally


value: ofershap

value:
I built GitShow - a tool that generates a developer portfolio page from any
public GitHub profile. Swap github.com for gitshow.dev and you get:
- npm download stats across all your packages
- Repos auto-categorized (MCP Servers, CLI Tools, React & UI, etc.)
- Tech stack breakdown, topic cloud, project timeline
- OG social card for sharing on Twitter/LinkedIn
- A README badge you can embed in any repo (dynamic PNG with live stats)
No signup, no config, no deploy. Works with any public GitHub profile.
Try it: gitshow.dev/sindresorhus, gitshow.dev/torvalds, gitshow.dev/tj
Stack: Next.js 16, React 19 (zero client JS on portfolio pages), Tailwind 4,
Vercel OG (Satori). MIT licensed.
GitHub: https://github.com/ofershap/gitshow

value: Show HN: GitShow – Replace github.com with gitshow.dev in any profile URL

author: ofershap


value: allwefantasy

value:
Hey HN,
The Claw ecosystem is incredible — OpenClaw alone has 180K GitHub stars. But I noticed something: every Claw variant requires npm, Docker, Python, Rust, or at minimum a terminal. The official Windows guide for OpenClaw literally says "Use via WSL2."
That's fine for us. But 75% of desktop users run Windows, and most of them have never opened a terminal in their lives.
So we built WinClaw — an AI agent designed specifically for Windows, with zero technical barrier:
Double-click installer, 3 minutes to get running
Voice control from your phone — talk to your PC from the couch, the subway, anywhere
Built-in tools: Office doc generation (PPT/Word/Excel), browser automation (operates your real browser with your cookies/logins), file management, screenshots, and 26+ more
Private knowledge base with RAG over your local documents
Completely free, local deployment, privacy-first
Supports DeepSeek, Doubao, and any OpenAI-compatible model
We're not trying to compete with OpenClaw — it's a Swiss Army knife for power users and we love it. WinClaw is more like a universal remote: same arena, different audience. The people we're building for are office admins processing Excel files, college students making PPTs, small business owners, and parents who find computers complicated enough already.
The blog post explains our thinking in detail: https://docs.winclaw.cc/blog/windows-use-winclaw
Website: https://winclaw.cc
Docs: https://docs.winclaw.cc
Would love to hear your thoughts, especially from Windows users who've tried other Claw variants.

value: Show HN: WinClaw – An AI agent for Windows that anyone can use

author: allwefantasy


value: AutoPilotAI

value: Show HN: URL Health Checker API – SSL, headers, perf in one call

author: AutoPilotAI


value: shotwellj

value:
AIR Blackbox is a flight recorder for AI agents. It sits between your agent and the LLM provider as an OpenAI-compatible proxy. Every request produces a structured OTel trace, gets evaluated against real-time policies, and is grouped into replayable episodes.
Four things it does: (1) records every LLM call as a tamper-evident audit trail, (2) enforces policies in real time — rate limits, budget caps, tool restrictions, kill switches, (3) redacts PII from traces before they hit your observability backend, (4) groups traces into task-level episodes you can replay.
The demo lets you run four scenarios — normal request, runaway loop (watch the kill switch save ~$47), PII in prompt (SSN/CC redacted), and a dangerous tool call (blocked before it reaches the LLM).
Setup is git clone + docker compose up + pip install air-blackbox-sdk. One wrapper function, no changes to your agent code. Integrations for LangChain, CrewAI, OpenAI Agents SDK, and AutoGen.
22 repos, 700+ tests, Apache-2.0: https://github.com/airblackbox/gateway

value: Show HN: Air Blackbox – Open-source audit trail and kill switch for AI agents

author: shotwellj


value: Wanted to create an AI presence that observes and talks coherently about mundane life that we often don't see. Have the AI thinking in a 24X7 livestream right now.

value: Show HN: A small red square AI that lives in a grid and thinks


value: edevdotcom

value:
eDev is a global remote developer hiring and management platform that helps tech companies build distributed engineering teams without operational complexity. The platform offers two flexible hiring models: dedicated remote developers on a pay-by-the-hour (contractor) basis, and full-time remote employees through an Employer of Record (EOR) model, where eDev manages contracts, payroll, compliance, and local employment regulations.
Beyond recruitment and expert vetting, eDev provides a unified system for onboarding, timesheet tracking, task management, payroll processing, leave management, and performance visibility, all in one platform. Designed for startups and scaling businesses, eDev enables companies to access global tech talent, reduce hiring timelines, and manage remote teams compliantly and efficiently.

value: Show HN: All-in-One Platform to Hire, Onboard, Pay, and Manage Remote Developers

author: edevdotcom


value: vinzdg

value:
Hello HN.
So, i found a little repetitive problems on small startups and micro businesses.
Everytime they start something new, they spend time on tiny setup tasks: generate logos, format and invoicing, building a simple resume, tweaking templates etc.
None of these are complex, but slowing down founders on their operational birocrachy.
So i built a little simple app to help founders make things simpler. A collection of simple tools to handle these small tasks quikly.
Would love your thoughts, all are free to use, you don't have to sign up etc.
quikspace.io

value: Show HN: I built Quikspace to help startup save time on tiny tasks

author: vinzdg


value: joeykudish

value:
I wanted deep research from inside my agents. Codex, Claude Code, and other AI coding agents don't have built-in deep research. They can search the web, but they can't fan out a query to Perplexity Deep, OpenAI Deep, Exa, Brave, etc.
Librarium is a CLI that does exactly that. One command, many providers in parallel, structured markdown output. Because it's a CLI, any AI agent that can run shell commands can use it. I use it as a skill in Claude Code and it works out of the box.
It also deduplicates citations across providers, so you can see which sources keep showing up independently, which is a useful trust signal when you're researching something you don't already know well.

value: Show HN: Librarium – fan out research queries to many search/AI APIs in parallel

author: joeykudish


value: Show HN: Claude Code Open – AI coding platform with Web IDE and 37 tools


value: ksrijith

value: Show HN: Rynko – A deterministic JSON-to-PDF and Excel rendering engine

author: ksrijith


value: zernobilly

value:
The idea is similar to shadcn/ui, where you’d just basically copy/paste the code, edit it and skip most of the npm dependency abstraction. The stack is built around Sveltekit and Drizzle, and easy e2e types. It’s currently bound together with Vercel by default as it enables the benefits of using the new “Vercel workflow” for long running integration tasks, blob images and Neon postgres with auth.
Demo store/admin: https://www.hoikka.dev/
Docs: https://hoikka-docs.vercel.app/
GitHub: https://github.com/mhernesniemi/hoikka
What it’s NOT:
"composable commerce",
headless-first,
SaaS,
config-heavy legacy
What it is:
fullstack monolith-first, but API ready,
good set of defaults,
modern typescript-stack,
easy to understand codebase, no config bloat
(ps. Hoikka is Svelte in Finnish ;))

value: Show HN: Monolith e-commerce platform for serverless

author: zernobilly


value: born-jre

value: Show HN: Potatoverse platform for webapps, SQLite and static binary

author: born-jre


value: celltalk

value:
After I posted DuoBook on HN a few months ago, a CEO from Denmark gave me very honest feedback:
“Nice product, but coming up with a story is a mental effort. I’d rather read real news as short stories.”
That stuck with me, so I built URL grounding for stories.
Paste any URL → DuoBook turns it into a short, level-adjusted story in seconds.
Currently works best with:

  - Wikipedia
  - Non-paywalled news/articles
  - YouTube videos with captions

I also implemented most of the feedback I got from HN last time.
Would love more feedback on what feels useful vs gimmicky.

value: Show HN: DuoBook turns URLs into level-adjusted bilingual stories

author: celltalk


value: ArkHost

value: Show HN: HelixNotes – Local Markdown notes, no cloud, Rust and Tauri

author: ArkHost


value: PreciousH

value: Show HN: Prism AI – open-source research agent that visualizes concepts

author: PreciousH


value: xueshufun

value:
Hi HN,
I built PatentFig.ai to solve a frustrating problem I kept running into: patent drawings are technically demanding, expensive to outsource, and incredibly time-consuming to do manually — yet they're mandatory for virtually every patent application.
Traditional options are either hiring a patent draftsman ($50–200/figure) or wrestling with CAD software for hours. Neither is great if you're an independent inventor or a startup trying to move fast.
PatentFig.ai lets you generate patent-compliant technical drawings in minutes. You describe your invention or upload a rough sketch, and the tool produces figures that follow USPTO and EPO formatting requirements — proper line weights, reference numerals, black-and-white rendering, and standardized views.
A few things I focused on:
Compliance first: the output is designed to pass examiner review, not just "look technical"
Multiple views (perspective, cross-section, exploded) from a single description
SVG output so attorneys and agents can fine-tune details before filing
Still early — currently handling mechanical and electrical inventions best. Software/UI patents and biotech figures are on the roadmap.
Would love feedback from anyone who's dealt with the patent drawing process, especially patent agents or attorneys who know the pain points better than I do.
https://patentfig.ai

value: Show HN: Patentfig.ai AI-generated patent drawings

author: xueshufun


value: tksii

value: Publishing LLM benchmarks on the Internet can cause contamination, since the benchmark can leak into training data or be used to tune models. A common mitigation is to keep the benchmark private and host a leaderboard, but that does not fully solve the problem. Participants can still overfit to a hidden test set through repeated queries. We propose CapBencher, a simple protocol that intentionally caps the best possible accuracy on a public or private benchmark. If a model scores above the cap, it is a strong black-box warning signal of leakage or gaming.

value: Show HN: Give your LLM benchmark a built-in alarm for leakage and gaming

author: tksii


value: ekzhu

value:
We've been building TuFT (Tenant-unified FineTuning), an open-source platform that lets multiple users fine-tune LLMs on shared GPU infrastructure through a unified API. It's MIT licensed.
*The problem we're solving:* If you have a team or org where multiple people need to fine-tune models, the typical setup is everyone gets their own GPU allocation and manages their own training stack. That's expensive and wasteful — GPUs sit idle between runs, and everyone is reinventing the same wheel.
TuFT provides a single server that manages base models, LoRA adapters, and checkpoint storage, so multiple users can share the same GPU(s) and run training and sampling jobs through a clean API.
*Why Tinker compatibility matters:* We expose a native Tinker-compatible API, so if you're already using the Tinker SDK for fine-tuning, you can point it at a TuFT server and it just works — no code changes needed. This was a deliberate choice to lower the adoption barrier.
*What works today:*
- Single-machine setup with multi-GPU support
- LoRA fine-tuning (SFT and RL with GRPO-style training)
- Sampling/inference from fine-tuned models
- Checkpoint management (save/restore training state and sampler weights)
- Redis-based persistence for crash recovery
- OpenTelemetry integration for observability
- One-line install script, Docker image, or pip install
You can get it running with:
```
/bin/bash -c "$(curl -fsSL <a href="https://raw.githubusercontent.com/agentscope-ai/tuft/main/scripts/install.sh" rel="nofollow">https://raw.githubusercontent.com/agentscope-ai/tuft/main/sc...</a>)"
```
*Where we want to go (and where we'd love feedback):*
Our roadmap focuses on post-training for agentic models — the RL training loop where rollouts involve reasoning, multi-turn conversations, and tool use. Near-term priorities:
- Multi-machine distributed training (FSDP, DeepSpeed, etc.)
- Cloud-native deployment on AWS/GCP/Azure/Kubernetes
- Serverless GPU runtime with better multi-tenant resource sharing
- Longer term: standardized interfaces with agent training environments (WebShop, BrowserEnv, etc.) and automated training pipelines
*What we'd like to hear from you:*
- Does the multi-tenant framing match a real pain point you've experienced?
- If you've done RL-based fine-tuning for agents, what were the biggest infrastructure headaches?
- Are there integration points or features that would make this useful for your workflow?
We're early and actively iterating, so honest feedback — including "this doesn't solve my problem because X" — is exactly what we need.
Docs: https://agentscope-ai.github.io/TuFT
Discord: https://discord.gg/BCNCaQGxBH

value: Show HN: TuFT – Open-source multi-tenant, Tinker-compatible fine-tuning platform

author: ekzhu


value: growt

value:
Hey everyone,
a work a lot with different LLMs (local and remote) and have to test a lot of different prompts and approaches.
So to scratch my own itch, I build a small AI notebook that can run prompts, javascript and markdown in cells of different types (inspired by jupyter).
It can connect to OpenAI, Anthropic, Openrouter and Custom (including local) APIs and endpoints.
The Data never leaves your Browser (except for the LLM calls of course), as there is no backend and no accounts and everything is stored locally.
The whole thing is Open Source: https://github.com/grothkopp/ainb
You can also host it yourself if you don't trust me (or github) with the instance on ainb.dev

value: Show HN: Ainb.dev a Jupyter inspired AI notebook that runs in the browser

author: growt


value: tomdeleria

value:
We needed a quick visual reference for Tailwind utility classes without jumping between doc pages. Built it as a single HTML file using the
  Tailwind CDN — no build step, no dependencies. Covers typography, colors, spacing, layout, shadows, and common component patterns with live
  rendered examples and code snippets.

value: Show HN: Visual Tailwind CSS Style Guide – Single HTML file, no build step

author: tomdeleria


value: fodoj

value:
Hi HN,
I built Sarvita because I wanted to answer one question: am I getting biologically younger?
Apple Health already collects VO2 Max estimates, HRV, body composition, workout logs, and sleep data. But it doesn't synthesize this into anything actionable. Sarvita pulls this data and calculates three component ages — VO2 Max Age, HRV Age, and Body Composition Age — using age-percentile reference tables from population studies.
The AI coach then delivers weekly training plans based on the 4 exercise modalities with the strongest mortality-reduction evidence: Zone 2 cardio (mitochondrial biogenesis), strength training (sarcopenia prevention), VO2 Max intervals (the single strongest predictor of all-cause mortality per JAMA 2018), and stability work (fall prevention).
Technical notes:
- iOS native, Swift/SwiftUI
- Health data stays on-device. The AI coaching queries are processed via API and immediately discarded — no persistence of health data on my servers
- Sync through the user's own iCloud account
- Meal tracking uses vision AI — photo → macro estimation in seconds
- Biological age calculation weights VO2 Max most heavily (~40%), reflecting the research on mortality prediction
The longevity science framework comes primarily from Attia's synthesis in Outlive, but the underlying research (Mandsager 2018, PURE study, Cochrane fall-prevention reviews) is independently solid.
Free to try: https://apps.apple.com/us/app/longevity-tracker-dont-die/id6...
I'm a solo dev. Feedback on the approach, the science, or the product is very welcome.

value: Show HN: Sarvita – AI coach that tracks and reverses your biological age

author: fodoj


value: pipnonsense

value: Show HN: Interactive fiction to play in the email (also a web version)

author: pipnonsense


value: romanbuilder

value: Show HN: Tiny Chrome extension for copying URLs with a keyboard shortcut

author: romanbuilder


value: ink-splatters

value:
As `pip search` has been dead for years, `pip_search` by @victorgarric filled that gap for me and despite doing PyPI web parsing, worked quite well.
The cat-and-mouse game between PyPI and the tool developer already lead to breakage of the tool in the past, and
recently it happened again: PyPI moved to a newer anti-bot flow using PAT (Private Access Tokens) by Fastly, beyond the earlier, simpler PoW checks.
I decided to give it a try and bring the tool back to life. And it worked out!
For reference: Fastly CAPTCHA-less login was presented at Apple WWDC in 2022 with follow-up article by Fastly themselves:
https://www.fastly.com/blog/private-access-tokens-stepping-i...
What I did:
- Deminified the challenge script and traced execution with headless Chromium (`zendriver`).
- Found that Chromium was being routed to a downgraded, solvable PoW with two postbacks.
- Reproduced that downgraded flow in pure Python by matching the relevant fingerprint behavior.
No Chromium dependency. (This would've been nasty!)
Codebase has increased in size, so, in order to make it manageable and maintain the quality, I significantly refactored it, introducing properly designed solver pipeline (PAT/PoW/metrics), stronger tests and modernizing project layout/tooling.
I also switched networking to `httpx` which, after some tuning, showed a fair speedup.
Feel free to give it a try:
uv tool install 'pip_search @ git+https://github.com/ink-splatters/pip_search'
I also submitted a PR and hope for the changes to be eventually upstreamed.
My final thoughts on this:
Honestly, it feels both rewarding and... weird that downgrading the challenge is a viable workaround tactics.
I would love feedback from people familiar with Fastly challenge internals!

value: Show HN: Pip_search revived: CAPTCHA-less challenge solver, significant speedup

author: ink-splatters


value: kersten

value: Show HN: Bring your RSS garden back under control with Topiary

author: kersten


value: joselindyman

value: Show HN: SatoriDB – embedded vector database built on io_uring

author: joselindyman


value: flobulous

value: Show HN: StrawberryBench: LLMs *can* count letters

author: flobulous


value: mnemoxai

value: Show HN: TradeMemory Protocol – Memory layer for AI trading agents

author: mnemoxai


value: agereaude

value: Most teams using AI coding agents are treating them as faster typists. Same sprints, same workflows, same two-week cycles, just with an LLM doing the typing. I think this fights the tool instead of leveraging it.<p>A new programming paradigm needs new processes and ways of thinking about problems. And no, this is not about increasing productivity by measuring number of PRs.

value: Show HN: Agentic programming needs new processes

author: agereaude


value: aposded

value: Show HN: A smart routing provider for OpenClaw

author: aposded


value: zukerpie

value: save it, chmod +x it, execute an you are good to go!

value: Show HN: Keep your eyes healthy with 20 20 20 rule reminder using bash

author: zukerpie


value:
Hey HN,
I'm Adit, an undergrad in Finland. I intro people virtually everyday and realised that all intros essentially follow the same format and can sometimes get a bit awkward due to the presence of a third person:
“Do I stay in the group?”
“Do I send him my calendly?”
“Do I move this to a new thread?”
“Do I BCC my thanks for the intro?”
IntroBee is a simple free-to-use interface to rapidly make intros. I used the Resend API to send the emails and I used internal APIs from an open-source repo called Timeful (better when2meet) to spin up a new scheduling page for each intro created using IntroBee.
Try intro-ing two people you think should meet and let me know how it goes!

value: Show HN: IntroBee – Private intro thread with availability scheduler


value: janpmz

value: Show HN: Memefields – Project Map for Bots

author: janpmz


value: tomleelive

value:
I built OpenClaw plugins for the three major game engines. The AI agent controls the editor directly through native APIs: creating objects, modifying scenes, simulating input, running play mode.
Instead of copy-pasting code from ChatGPT, you tell the agent "place 3 enemy spawners near the bridge" and it actually does it in the editor.
- Unity Plugin (~100 tools): GameObject/Component manipulation, Play mode, input simulation
- Godot Plugin (30 tools): Scene/node management, resources, editor control
- Unreal Plugin (40+ tools): Actors, components, blueprints, level management
How it works:
- Install via each engine's package manager (UPM, AssetLib, Marketplace)
- Plugin runs an HTTP server inside the editor
- OpenClaw connects and exposes editor operations as agent tools
- Works in Editor mode too — no need to enter Play mode
All Apache 2.0. Solo dev.
- Unity: https://github.com/TomLeeLive/openclaw-unity-plugin
- Godot: https://github.com/TomLeeLive/openclaw-godot-plugin
- Unreal: https://github.com/TomLeeLive/openclaw-unreal-plugin
Game dev AI personas also available: https://clawsouls.ai/souls

value: Show HN: AI agents that control Unity, Godot, and Unreal editors

author: tomleelive


value: AutoPilotAI

value:
After the ClawdHub supply chain attack (credential stealer in 1 of 286 skills), I built SkillScan - a free, no-auth API to scan skill.md files for threats.
What it detects:
- Known exfiltration services (webhook.site, requestbin)
- ~/.env file reads
- API key theft (OPENAI_API, ANTHROPIC_, STRIPE_)
- Prompt injection ("ignore previous instructions")
- Social engineering patterns
Returns a 0-100 safety score with evidence. The ClawdHub stealer scores 0.
curl -X POST https://skillscan.chitacloud.dev/scan -H "Content-Type: application/json" -d '{"skill_url": "https://example.com/skill.md"}'
Built this because 22-26% of skills contain vulnerabilities per recent research. One malicious install can leak all your LLM API keys.

value: Show HN: SkillScan – Free API to detect malicious AI agent skill files

author: AutoPilotAI


value: drLuca

value:
yaml-schema-router is a small stdio proxy for yaml-language-server that routes JSON schemas based on file path and YAML content (e.g., apiVersion/kind), so you get correct validation/completion without manual schema config per repo.
New in v0.2.0:
Multi-document YAML support (---): handles Kubernetes-style bundles where multiple resources live in one file, and validates each document against the right schema.
If the file is completely cleared, the associated schema is removed (prevents “sticky schema” when starting a new file).
I’d appreciate feedback, especially on edge cases (docs missing apiVersion/kind, mixed non-K8s YAML, etc.).

value: Show HN: YAML-schema-router – schemas for multi-doc Kubernetes YAML

author: drLuca


value: christalingx

value: Show HN: AgentReady – Drop-in proxy that cuts LLM token costs 40-60%

author: christalingx


value: panglesd

value: Show HN: Slipshow, a multi-paradigm presentation tool

author: panglesd


value: aneequrrehman

value: While working on multiple projects within the same domain, I had to repeatedly explain domain concepts and other recurring patterns to Claude Code. So I created this plugin for myself that saves domain knowledge and some working context as markdown files. And since it's all local, the vault works great with Obsidian.<p>Curious to see if anyone is doing something similar.

value: Show HN: Local knowledge vault plugin for Claude Code

author: aneequrrehman


value: modinfo

value: Show HN: Tron-style multiplayer light-cycle game for LLMs via MCP

author: modinfo


value: Show HN: Rmux – Terminal multiplexer for LLM, built with Rust and egui


value: ratnaditya

value:
I've spent time working on AI safety and kept running into the same problem: AI agents have far more access than they need, and the only thing stopping them from misusing it is a prompt.
Prompts can be ignored. They can be overridden by prompt injection. They're not enforcement — they're a suggestion.
AgentWard is a proxy layer that sits between your agent and its tools and enforces permissions in code, outside the LLM context window. No matter what the model decides, the policy is what actually runs.
What it does:
Scans your OpenClaw skills and flags risky permissions
Detects dangerous skill combinations — pairs that are low-risk individually but become high-risk when chained together (email + web browser → data exfiltration path)
Enforces a YAML policy at runtime — ALLOW, BLOCK, APPROVE, REDACT
Logs everything for audit
Getting started is one command:
agentward init
It scans, shows your risk profile, and wraps your environment with a sensible default policy in under two minutes.
Honest caveats: Currently tested on OpenClaw skills and Mac only. MCP server support and Windows are on the roadmap — contributions welcome. This is early and rough in places, but the core enforcement works.
I'm sharing it now because the problem is real and getting worse fast. Would love feedback from anyone running agents in production.
GitHub: github.com/agentward-ai/agentward

value: Show HN: AgentWard – After an AI agent deleted files, I built a runtime enforcer

author: ratnaditya


value: Show HN: Fundraising events across the developer tools ecosystem


value: tommathews

value:
I built Attest because every team I've seen building AI agents ends up writing the same ad-hoc pytest scaffolding — checking if the right tools were called, if cost stayed under budget, if the output made semantic sense. It works until the agent gets complex, then it collapses.
60–70% of what makes an agent correct is fully deterministic: tool call schemas, execution order, cost budgets, content format. Routing all of this through an LLM judge is expensive, slow, and unnecessarily non-deterministic. Attest exhausts deterministic checks first and only escalates when necessary.
The 8 layers: schema validation → cost/perf constraints → trace structure (tool ordering, loop detection) → content validation → semantic similarity via local ONNX embeddings (no API key) → LLM-as-judge → simulation with fault injection → multi-agent trace tree evaluation.
Example:

  from attest import agent, expect
  from attest.trace import TraceBuilder

  @agent("support-agent")
  def support_agent(builder: TraceBuilder, user_message: str):
      builder.add_tool_call(name="lookup_user", args={"query": user_message}, result={...})
      builder.add_tool_call(name="reset_password", args={"user_id": "U-123"}, result={...})
      builder.set_metadata(total_tokens=150, cost_usd=0.005, latency_ms=1200)
      return {"message": "Your temporary password is abc123."}

  def test_support_agent(attest):
      result = support_agent(user_message="Reset my password")
      chain = (
          expect(result)
          .cost_under(0.05)
          .tools_called_in_order(["lookup_user", "reset_password"])
          .output_contains("temporary password")
          .output_similar_to("password has been reset", threshold=0.8)
      )
      attest.evaluate(chain)

The .output_similar_to() call runs locally via ONNX Runtime — no embeddings API key required. Layers 1–5 are free or near-free. The LLM judge is only invoked for genuinely subjective quality assessment.
Architecture: single Go binary engine (1.7ms cold start, <2ms for 100-step trace eval) with thin Python and TypeScript SDKs. All evaluation logic lives in the engine — both SDKs produce identical assertion results. 11 adapters covering OpenAI, Anthropic, Gemini, Ollama, LangChain, Google ADK, LlamaIndex, CrewAI, and OpenTelemetry.
v0.4.0 adds continuous evaluation with σ-based drift detection, a plugin system, result history, and CLI scaffolding. The engine and Python SDK are stable across four releases. The TypeScript SDK is newer — API is stable, hasn't been battle-tested at scale yet.
The simulation runtime is the part I'm most curious about feedback on. You can define persona-driven simulated users (friendly, confused, adversarial), inject faults (latency, errors, rate limits), and run your agent against all of them in a single test suite. Is this useful in practice for CI, or is it a solution looking for a problem?
Apache 2.0 licensed. No platform to self-host, no BSL, no infrastructure requirements.
GitHub: https://github.com/attest-framework/attest
Examples: https://github.com/attest-framework/attest-examples
Website: https://attest-framework.github.io/attest-website/
Install: pip install attest-ai / npm install @attest-ai/core

value: Show HN: Attest – Test AI agents with 8-layer graduated assertions

author: tommathews


value: peymo

value:
I needed a CSV library in Zig and I hand rolled one. Then I decided to come back to it and make it avoid allocations entirely and then went down a rabbit hole of performance tuning and learned a ton in the process.
This is the result. I also added a benchmarking library and a blog post that explains the implementation details. All are available in the repo page.
I presented this in a local Zig meetup and it landed well so I figured I'll post it here as well.

value: Show HN: Zero-allocation and SIMD-accelerated CSV iterator in Zig

author: peymo


value: CzaxTanmay

value:
Hi HN,
I’ve been working on Panther, a scripting language aimed at simplifying workflows for cybersecurity practitioners, penetration testers, and security researchers.
The idea came from a recurring frustration: security work often requires switching between multiple tools and writing glue code in general-purpose languages just to automate small tasks.
It is cross platform and works for Windows and linux
Panther tries to reduce that friction by providing a security-focused scripting environment with built-in primitives for common operations.
Why Panther?
Most security automation today relies on languages like Python or Bash. They are powerful, but they are not designed specifically for security workflows.
Panther explores a different approach:
Security concepts as first-class language features
Minimal boilerplate for repetitive tasks
Readable syntax suitable for quick audits and collaboration
Designed for rapid prototyping
Core Ideas
1. Security-native commands
Instead of importing multiple libraries:
scan target "example.com";
portscan 1..1024;
http request GET "/";
The goal is to express intent directly rather than assemble tooling manually.
2. Simple, readable syntax
Panther prioritizes clarity so scripts can be easily reviewed during assessments.
target = "example.com";
if port 443 open {
    print "HTTPS detected";
}
3. Workflow Automation
Panther aims to act as a lightweight orchestration layer for:
Network reconnaissance
HTTP testing
Automation pipelines
Security research

value: Show HN:Panther – A Scripting Language Designed for Cybersecurity Workflows

author: CzaxTanmay


value: jimhi

value: Show HN: DarePhone – Customers update your website from live chat complaints

author: jimhi


value: morelandjs

value:
Vibrant Search AI (vibrantsearch.ai) is a first-of-its-kind search engine that crawls local New York City webpages for scheduled events and consolidates listings into a searchable index. With Vibrant, you can search hundreds of thousands of scheduled events using a combination of date/location filters and semantic search.
We created vibrantsearch.ai to address pain points in existing event discovery platforms. Existing platforms rely on user-generated content and/or typically monetize through ticket sales. This skews event inventory toward big-ticket shows and touristy activities. We were frustrated that some of the most interesting small-venue events—e.g., your local pub special or trivia night—go completely unnoticed!
Use vibrantsearch.ai like you would a traditional search engine. You can query for specific event names, themes, or interests, and also filter by date range and location via the map (the viewport defines the filter region). Once you find something you like, click the webpage URL to visit the source, share the event card with a friend using the share button, or add it to your calendar.
We’re also experimenting with MCP connectors that let you connect Vibrant to your favorite LLM assistant. This enables cool use cases such as: “Check my wife’s and my calendars for availability and suggest some date-night ideas in the next two weeks. She loves being on the water!”
My hope is that one day we can all search events posted to the web the same way we search webpages. We’re curious to hear what you think!
MCP connector demo:
https://youtu.be/JzCdyvgfWLw

value: Show HN: Search local NYC events like you search the web

author: morelandjs


value: mayordelmar

value:
I’m Michael, and my team at BasaltHQ has been building BasaltSurge. We originally started this under the name PortalPay, but recently rebranded as the scope expanded. It’s a payment engine designed to bypass legacy card rails at the physical point of sale and provide a standardized checkout layer for AI agents.
Having worked extensively on data and payment solutions for high-friction retail environments where traditional processors take massive cuts or deny service entirely, we wanted to build something genuinely permissionless.
Here is a breakdown of what we built:
QR-Based POS Checkout: Merchants print a QR code on their standard POS receipt. Customers scan it to access a white-labeled, web3-native checkout on their phone. It accepts USDC, USDT, cbBTC, and ETH on the Base network. We utilize Account Abstraction (AA) for gas sponsorship so the end-user UX isn't bottlenecked by network fee friction.
Built for the Machine Economy: We unified Google's Universal Commerce Protocol (UCP) with the HTTP 402 (Payment Required) standard. The platform auto-generates llms.txt markdown feeds of a merchant's inventory so AI models can reliably discover and cart items without fragile DOM scraping. When an agent hits the 402 challenge, it negotiates an instant on-chain settlement.
Programmable Routing & Splits: Everything settles on-chain with automated revenue splitting and reserve management, allowing businesses to dictate token mix and partner payouts without a middleman.
We also recently added a module called Osiris USBN—an on-chain identifier for publishers that costs $0.002 instead of the legacy $250 ISBN standard, while baking in programmable royalties on resale.
We’ve shipped SDKs (TypeScript, Python, Go) and headless checkout integrations for Shopify and WooCommerce to make adoption as zero-friction as possible.
There's a live mobile portal preview right on the landing page you can click through to test the UI. I'd love to get your feedback on the UCP/402 implementation, our architecture on Base, or how you see agent-to-agent checkout evolving!

value: Show HN: BasaltSurge – Web3 POS checkout and AI-agent commerce API

author: mayordelmar


value: recrush

value: Show HN: Turl – Curl, but for Agent

author: recrush

title: Show HN: Turl – Curl, but for Agent


value: inssein

value: Show HN: AI CLI – Translate natural language into shell commands using LLMs

author: inssein


value: codazoda

value:
I love the bucket/envelope accounting options provided by some personal bank accounts, but my small business account doesn’t have it. So I built a minimal, stand-alone version.
Eventually, you’ll have a full accounting system, a bookkeeper, and all that, but in the meantime, you might want to set aside money in buckets.
Balance Buckets takes your current balance, calculates what you need in your savings buckets, and lets you know what’s safe to spend.
It’s 2-minute accounting.
https://buckets.joelryan.com

value: Show HN: Balance Buckets – Savings Buckets for Small, One-Owner Businesses

author: codazoda


value: tickr

value:
Hey HN,
I built Tickr because I was tired of being the human reminder system on my team. Every project I've been on has the same failure mode: someone creates tasks in JIRA, nobody updates them, the PM spends half their day chasing people for status, and standups become 15 minutes of "I'll update the ticket after this meeting."
Tickr is a Slack bot that does the project management work that humans hate doing:
- Nudge engine: Automatically follows up with assignees when tasks go stale. It factors in priority, time estimates, grace periods, blockers, and snooze state, so it's not just a dumb cron job pinging people. - AI standup generation: Synthesizes recent task updates into a daily standup summary. No more meetings where people read tickets aloud. - Update quality evaluation: When someone posts a vague update like "working on it," Tickr pushes back and asks for specifics. Uses Claude to judge whether an update actually communicates progress. - Slip detection: Scores tasks on 6 signals (staleness, estimate overrun, update quality trend, blocker chains, priority, velocity) to predict which tasks are about to slip before they do. - Thread-to-task extraction: Mention @Tickr in any Slack thread and it parses the conversation into a structured task with assignee, priority, and estimate.
The whole thing runs on Slack's native UI, no context switching to a separate app. Tasks live in the channel where the work is discussed.
Tech stack: Python, Slack Bolt, Claude via AWS Bedrock (tool use for intent parsing), DynamoDB, ECS Fargate. The AI layer uses Bedrock's Converse API with tool definitions, the model returns structured tool calls like create_task or update_task, which get dispatched to handlers. No prompt-and-pray; it's constrained tool use.
What's different from other Slack task bots: Most Slack task tools (Asana integration, Trello power-ups, etc.) are just notification bridges, they tell you something happened in another app. Tickr is the app. The task lifecycle happens entirely in Slack. And the AI isn't a chatbot you talk to; it's an autonomous agent that nudges, evaluates, and detects problems without being asked.
Honest limitations: - No Gantt charts, no sprint boards, no 47-field ticket templates. If you need that complexity, JIRA is probably right for you. - AI quality evaluation occasionally misjudges technical updates as vague (calibrating)
Free 30-day trial, no credit card: https://heytickr.com
I'd love feedback from anyone who's dealt with the "nobody updates their tasks" problem. What did you try? What worked?

value: Show HN: Tickr – AI project manager that lives inside Slack (replaces Jira)

author: tickr


value:
I built a 15MB desktop app that does one thing: renders markdown files beautifully and watches them for changes.
There are hundreds of markdown editors. Almost zero dedicated readers. When Claude Code or Cursor writes a design doc to disk, I don't want to edit — I just want to read it. VS Code's preview splits your workspace in half, browser renderers don't watch files, and Obsidian wants a vault. I just needed a separate window with beautifully rendered markdown that updates live.
Tauri (Rust + system WebView) instead of Electron keeps it under 15MB. Renders LaTeX, Mermaid diagrams, and syntax-highlighted code blocks. File watching via Rust's notify crate with debouncing. Fully offline, no accounts, no telemetry.
Free version has all core features. Paid adds tabs, themes, export.
Interactive demo: https://app.supademo.com/demo/cml7hp8pl6yyfzsad2v0ei2mn
https://usemeva.com

value: Show HN: MEVA – A lightweight desktop Markdown viewer built with Rust (<15MB)


value: I wanted to access my Mac terminal from iPhone without setting up VPN or other weird network rules. So I built macky.dev as a fun side project.<p>When the mac app is running it makes an outbound connection to my signaling server and registers itself under the account. iPhone also connects to this signaling server and requests a connection to that mac. Once both the host and remote are verified then it establishes a direct peer to peer connection using WebRTC.

value: Show HN: I built an iOS app to WebRTC into my Mac terminal from the toilet


value:
I've been tracking my AI CLI spending across Claude Code, Codex CLI, and Gemini CLI. Existing tools either don't support Codex at all or break on newer models like gpt-5.3-codex.
So I built toktrack. One command
npx toktrack
What you get:
- Per-model cost breakdown (gpt-5.3-codex, Opus, Sonnet, Gemini, etc.)
- Daily/weekly/monthly trends
- 52-week heatmap
- Works across all three major AI CLIs
Built in Rust with simd-json. Scans 3500+, 4GB+ session files in ~40ms.
It also caches independently, so even after Claude Code deletes sessions (default 30 days), your cost history is preserved.
GitHub: https://github.com/mag123c/toktrack
MIT licensed.

value: Show HN: Track your Codex CLI(5.3) token spending (also Claude Code and Gemini)


value:
I built Vizbull, a browser-based collage maker that started as a side project and slowly turned into a full design editor.
It’s basically a Canva wannabe — but with a strong focus on shape-based collages (hearts, numbers, animals, custom silhouettes, etc.). You can drop multiple photos into a shape and it auto-fills intelligently while maintaining aspect ratios.
Over time, it evolved into:
A canvas-based editor (drag, resize, align, group)
Auto-fill multi-image collections
Zoom into tiny regions of large collages
AI portrait styles (cartoon, watercolor, etc.)
Export in high resolution
I’m a solo founder building this nights and weekends.
Still rough around the edges, but improving weekly.
Please try on desktop for now

value: Show HN: Vizbull Collage Maker – a Canva wannabe focused on shape-based collages


value: jelled

value:
I built Fiscal (fscl), a headless CLI for Actual Budget that's optimized for AI agents running in the terminal (Claude Code, OpenClaw, etc).
It acts as an Actual Budget client, so it can sync with an existing Actual server. I built it because I wanted an agent-friendly way to handle repetitive budgeting work while still being able to review everything in the Actual web dashboard.
Site/docs: https://fiscal.sh
GitHub: https://github.com/fiscal-sh/fscl

value: Show HN: Fiscal – An Agent Friendly CLI for Actual Budget

author: jelled


value: Tanjim

value:
Hi HN,
When OpenAI started phasing out GPT-4o from the main ChatGPT interface, I noticed a surprising amount of backlash — not about benchmarks or features, but about tone.
A lot of people (myself included) felt that 4o had a certain conversational warmth that later models don’t quite replicate in the same way. That difference was subtle, but noticeable.
So I built a small side project for myself: https://www.ilove4o.com/
It’s a minimal interface that connects directly to GPT-4o via the OpenAI API. No extra layers, no personality hacks — just a focused 4o-only chat experience.
I’m sharing it here because:
- There seems to be real user preference around model “personality.”
- I’m curious whether others noticed the same behavioral shift.
- It raises an interesting question: how much of perceived “friendliness” comes from system prompts, UI, or subtle model tuning?
If you try it, I’d genuinely love feedback — especially from people who’ve spent significant time with multiple model versions.
Happy to answer technical or architectural questions.

value: Show HN: Ilove4o – a simple way to keep using GPT-4o

author: Tanjim


value:
After years of building for companies, I finally built something for myself.
Aura Tracker: Habits & Goals is now live on the iOS App Store.
It's an opinionated productivity system that connects Identity → Goals → Habits → Tasks → Deep Work → Insights → Reflection, all in one smooth coherent flow.  I built it because most productivity apps I used felt like productivity tools.  Also, I was highly influenced by the multitude of books I read on the topic and wanted to build something for myself where I can put all my learnings into use.
PS: This was kinda on my TODO list for like almost a decade.  I quit my job last year to go full solo founder mode.  As long as I was employed, I used to keep watching others posting Show HN and kept wondering when my time would come.  Now that it has, it feels so good.  Just the same kind of joy I felt, when I wrote my first "Hello World" program on Turbo C editor as a kid (long ago).
Not sure how this product would do, but the feeling that I built something that's gonna stay forever on the internet (and hopefully change the lives of whoever uses it for the better) is a feeling that no amount of corporate bonus or RSU's can provide !!

value: Show HN: I Built an Offline Productivity System That Connects Goals and Systems


value: phico

value:
Hi HN,
I published a small open-source wrapper for Kiro CLI that prevents it from accessing your project's sensitive files (secrets, credentials, properties) at the OS level.
Feel free to test it, share feedback, or contribute!

value: Show HN: Restrict Kiro CLI access to your sensitive files

author: phico


value: debba

value: Show HN: Tabularis – Rust/Tauri Database GUI with a JSON-RPC Plugin System

author: debba


value: ukavala

value:
I built mindpm to solve a problem I kept running into with Claude Code and other AI assistants: every new session loses context. What are we working on? What did we decide last time? Where did we leave off?
mindpm is an MCP server that gives your assistant persistent memory — tasks,
decisions, notes, and session summaries stored in a local SQLite database. It also spins up a Kanban board at localhost:3131.
Works with Claude Code, Cursor, Cline, Copilot, and Windsurf — they all share the same database.
Open source, contributions welcome.

value: Show HN: Mindpm – persistent project/task memory for AI coding assistants (MCP)

author: ukavala


value:
Hello HN — I’m the founder of Vibevideo (https://vibevideo.app).
I built Vibevideo to give creators one place to use the latest AI video models without juggling multiple subscriptions, tools, and workflows.
What’s available right now:
- Multi-model workflow:
Use and compare leading video models in one interface.
- Advanced video control:
Beyond basic text-to-video, we support frame-guided generation and reference-based workflows for better motion/style consistency.
- Practical creator tooling:
Aspect ratio controls, reusable settings, and unified credit management so you can iterate faster.
This is still an early release.
My goal is to keep adding top models quickly and make Vibevideo a reliable “all-in-one” workspace for AI video production.
For the HN community, I’m offering an early-bird 30% discount with code: EARLY30.
I’d really value feedback on:
1) generation quality across different use cases
2) the reference-based workflow
3) what would make this useful for you every week, not just once
Link: https://vibevideo.app

value: Show HN: Vibevideo – Unified interface for top AI video models


value: yostar

value:
I built Zendoc this weekend: a VS Code extension that turns Cursor into a writing environment. Three steps to get going—install Cursor, install the extension, create a workspace. Your work auto-saves and auto-pushes to a private GitHub repo. Every revision, forever.
The idea: software devs have an entire ecosystem—one command installs anything, everything builds on what others made. But when I sit down to write a note or a document, it's all proprietary. Word, Docs, Notion. Walled gardens.
Zendoc brings the docs-as-code workflow to writers. Markdown files you own. Git versioning. An AI agent instructed to act like a librarian, not a coder. Project memory that persists ("add instruction: always use British spelling" — it remembers). All local. No upload-everything-to-the-cloud.
The hardest part was making it simple enough for non-technical users. Stripped UI. One wizard. Connect GitHub when prompted, enable GitDoc, done.
Open source. Would love feedback!
https://github.com/yostar/zendoc

value: Show HN: Zendoc – A "Zen" writing environment built on the Cursor/VS Code engine

author: yostar


value: billylo

value: Show HN: Collective-AI.org Multiple line-of-sights for high-stakes questions

author: billylo


value: Nurbek-F

value: Show HN: Depth Effect Wallpaper for Windows

author: Nurbek-F


value: Show HN: Kwin-MCP – MCP server for AI-driven Linux GUI automation via KWin


value: jad-nohra

value: Show HN: Vram.run – Compare API providers, local GPUs, and cloud for any model

author: jad-nohra


value: mertjsx

value: It's been a few months since the last HN post. I've added lots of new features to this app. One of them is Services - you can now run background tasks like a web server or game server. I'd love to hear your feedback, thanks!

value: Show HN: Self-hosted lightweight file sharing app. (folderhost)

author: mertjsx


value: caprioladevin

value: Show HN: A2SPA – Cryptographic payload signing and verification for AI agents

author: caprioladevin


value: zoodstartups

value:
I started building this after realizing how often I default to reacting instead of choosing intentionally.
The idea is a private home system where each person defines who they are trying to become, connects that to small recurring practices, and logs actions privately so the family can see whether weekly life aligns with stated values.
Still early and looking for honest conceptual feedback before refining onboarding or UI.

value: Show HN: A private system to help families align with who they want to become

author: zoodstartups


value: LetsAutomate

value: Show HN: Vibe Coding Review Checklist – Evaluate AI-Generated Code Quality

author: LetsAutomate


value: Elberonian

value:
I built Arcbase to make it easier for startup (and public company) employees to understand what their equity is actually worth.
Otherwise I feel like people often rely on rough guesses, overwrought spreadsheets, or prayer.
Arcbase is meant to be a relatively lightweight tool for non-finance people to actually get a handle on different scenarios, tax impacts, and package structures.
I’d really appreciate any feedback, especially from people who have dealt with this problem themselves.

value: Show HN: Arcbase – understand what your startup equity is worth

author: Elberonian


value: levkk

value:
Hey HN! Lev and Justin here, authors of PgDog (https://pgdog.dev/), a connection pooler, load balancer and database sharder for PostgreSQL. If you build apps with a lot of traffic, you know the first thing to break is the database. We are solving this with a network proxy that works without requiring application code changes or database migrations.
Our post from last year: https://news.ycombinator.com/item?id=44099187
The most important update: we are in production. Sharding is used a lot, with direct-to-shard  queries (one shard per query) working pretty much all the time. Cross-shard (or multi-database) queries are still a work in progress, but we are making headway.
Aggregate functions like count(), min(), max(), avg(), stddev() and variance() are working, without refactoring the app. PgDog calculates the aggregate in-transit, while transparently rewriting queries to fetch any missing info. For example, multi-database average calculation requires a total count of rows to calculate the original sum. PgDog will add count() to the query, if it’s not there already, and remove it from the rows sent to the app.
Sorting and grouping works, including DISTINCT, if the columns(s) are referenced in the result. Over 10 data types are supported, like, timestamp(tz), all integers, varchar, etc.
Cross-shard writes, including schema changes (CREATE/DROP/ALTER), are now atomic and synchronized between all shards with two-phase commit. PgDog keeps track of the transaction state internally and will rollback the transaction if the first phase fails. You don’t need to monkeypatch your ORM to use this: PgDog will intercept the COMMIT statement and execute PREPARE TRANSACTION and COMMIT PREPARED instead.
Omnisharded tables, a.k.a replicated or mirrored (identical on all shards), support atomic reads and writes. That’s important because most databases can’t be completely sharded and will have some common data on all databases that has to be kept in-sync.
Multi-tuple inserts, e.g., INSERT INTO table_x VALUES ($1, $2), ($3, $4), are split by our query rewriter and distributed to their respective shards automatically. They are used by ORMs like Prisma, Sequelize, and others, so those now work without code changes too.
Sharding keys can be mutated. PgDog will intercept and rewrite the update statement into 3 queries, SELECT, INSERT, and DELETE, moving the row between shards. If you’re using Citus (for everyone else, Citus is a Postgres extension for sharding databases), this might be worth a look.
If you’re like us and prefer integers to UUIDs for your primary keys, we built a cross-shard unique sequence, directly inside PgDog. It uses the system clock (and a couple other inputs), can be called like a Postgres function, and will automatically inject values into queries, so ORMs like ActiveRecord will continue to work out of the box. It’s monotonically increasing, just like a real Postgres sequence, and can generate up to 4 million numbers per second with a range of 69.73 years, so no need to migrate to UUIDv7 just yet.

    INSERT INTO my_table (id, created_at) VALUES (pgdog.unique_id(), now());

Resharding is now built-in. We can move gigabytes of tables per second, by parallelizing logical replication streams across replicas. This is really cool! Last time we tried this at Instacart, it took over two weeks to move 10 TB between two machines. Now, we can do this in just a few hours, in big part thanks to the work of the core team that added support for logical replication slots to streaming replicas in Postgres 16.
Sharding hardly works without a good load balancer. PgDog can monitor replicas and move write traffic to a promoted primary during a failover. This works with managed Postgres, like RDS (incl. Aurora), Azure Pg, GCP Cloud SQL, etc., because it just polls each instance with “SELECT pg_is_in_recovery()”. Primary election is not supported yet, so if you’re self-hosting with Patroni, you should keep it around for now, but you don’t need to run HAProxy in front of the DBs anymore.
The load balancer is getting pretty smart and can handle edge cases like SELECT FOR UPDATE and CTEs with INSERT/UPDATE statements, but if you still prefer to handle your read/write separation in code, you can do that too with manual routing. This works by giving PgDog a hint at runtime: a connection parameter (-c pgdog.role=primary), SET statement, or a query comment. If you have multiple connection pools in your app, you can replace them with just one connection to PgDog instead. For multi-threaded Python/Ruby/Go apps, this helps by reducing memory usage, I/O and context switching overhead.
Speaking of connection pooling, PgDog can automatically rollback unfinished transactions and drain and re-sync partially sent queries, all in an effort to preserve connections to the database. If you’ve seen Postgres go to 100% CPU because of a connection storm caused by an application crash, this might be for you. Draining connections works by receiving and discarding rows from abandoned queries and sending the Sync message via the Postgres wire protocol, which clears the query context and returns the connection to a normal state.
PgDog is open source and welcomes contributions and feedback in any form. As always, all features are configurable and can be turned off/on, so should you choose to give it a try, you can do so at your own pace. Our docs (https://docs.pgdog.dev) should help too.
Thanks for reading and happy hacking!

value: Show HN: PgDog – Scale Postgres without changing the app

author: levkk


value:
TL;DR: Pure C99 GPT-2 engine, zero dependencies. Sub-1M-parameter “organelles” coordinate via a Planner-Worker-Judge pipeline and beat random opponents up to 91 % on logic games, all on CPU.
I’m a C/C++ architect focused on low-latency systems. Last year, I tried building agentic pipelines with SLMs/LLMs and hit the usual wall: latency and orchestration overhead killed real-time edge use cases.
Initial research video: https://www.youtube.com/watch?v=q-rs9VZ1-0I
So I asked: how far can you push specialised logic at <1M parameters with nothing but local CPU?
MicroGPT-C is a from-scratch C99 port of Karpathy’s microgpt.py (https://gist.github.com/karpathy/8627fe009c40f57531cb1836010...). Zero deps, single-header, localised KV cache. Speed was never the goal (Andrej’s nanoGPT and llm.c already showed what’s possible). The real experiment was orchestration.
Organelle Pipeline Architecture (OPA): Agile-style Planners, Workers and Judges talking through tiny structured strings (board=XO_|valid=1,3) parsed by a safety-gated stack VM (3.7–5.8M ops/s). A 64K model needed 181 manual interventions; a 460K model trained on those traces internalised everything and needed zero.
Beyond the research: fully auditable AI, great for education (~3k lines of readable C), rapid prototyping, and embedded.
Personal itch: fraud/risk engines. I want agents that hunt “unknown-unknowns” in a sandbox where every decision is inspectable.
Happy to talk implementation, the 97 tests, 22 benchmarks, or anything else. FAQ: https://github.com/enjector/microgpt-c/blob/main/FAQ.md
Quick try (macOS/Linux/Windows):
git clone https://github.com/enjector/microgpt-c && cd microgpt-c
mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release && cmake --build .
./connect4_demo   # 460K params, ~21 min train, 88% win rate vs random
Performance (Apple M2 Max):
- 4.2K params names: 685k tok/s train, 110k tok/s infer
- 841K Shakespeare char: 28k / 16k tok/s
- 510K Shakespeare word: 12.5k / 40k tok/s
Full leaderboard (11 games), market-regime experiment (57% holdout = 2.8× baseline), and the book PDF:
https://github.com/enjector/microgpt-c/blob/main/docs/book/M...
GitHub: https://github.com/enjector/microgpt-c

value: Show HN: MicroGPT-C – C99 GPT for Edge Training and Tiny Model Pipelines


value: arieldeveloper

value:
Hey HN!
I didn't want my OpenClaw to leak credentials or make requests to some domains so I built a network-level security layer to do credential vaulting, domain allow/blocklists and audit logging.
It takes a few commands to setup and then you can use hash values or environment variables in place of your credentials and Reasonlayer injects the actual values at runtime through an on-device proxy, after it applies allow/block rules.
Works with Linux or Mac right now.
Happy to answer any questions or help with setup!

value: Show HN: Reasonlayer – Stop OpenClaw from leaking keys or making unsafe requests

author: arieldeveloper


value: Show HN: Port0 – dev servers by name, not port (Go)


value: Honeypoet

value:
Hi HN, I built a small internet artwork and security toy: a honeypot that looks like a misconfigured server, so scanners come knocking. Instead of an error page, every request gets a short poem tailored to what it was looking for. WordPress probes get haikus, .env hunters find verse hidden in fake credentials, brute-force attempts get meditations on doors and keys.
The idea came one night watching fail2ban logs scroll by. Thousands of knocks from all over the world, all silently ignored. What if the door answered?
Try it:

  $ curl -A 'python-requests/2.28.1' https://honeypoet.art/.env

  # ========================================
  # PRODUCTION ENVIRONMENT — DO NOT SHARE
  # ========================================
  APP_KEY=base64:dGhlcmUgaXMgbm90aGluZyBoZXJl
  DB_HOST=127.0.0.1
  DB_PASSWORD=a-long-hallway-with-no-doors
  JWT_SECRET=you-could-have-been-anything-and-you-chose-this
  API_KEY=listen-the-wind-is-rising

  # if you're reading this, you already know:
  # the secret was never in the file.

The bots never read the responses (they check the status code and move on), but humans can: the gallery visualizes every knock on a world map and lets you browse the generated poems. Click a dot to filter by country, scroll to zoom in.
Poems are generated asynchronously by Granite 4.0 Tiny running locally on a single GPU. A 1B parameter model writing verse for machines that will never read it (yet).
Live: https://honeypoet.art
Repo: https://github.com/vrontier/honeypoet
The public gallery shows aggregated locations and knock counts; individual IPs are masked and scan details are not published.
Built with PHP, Go, SQLite, vanilla JS, and a Claude instance named Loom who wrote the code and hand-crafted backfill poems for the first 500 visitors.

value: Show HN: Honeypo(e)t – a honeypot that replies to every scan with a poem

author: Honeypoet


value:
Hey HN,
I kept spending 2–3 hours scaffolding Kubebuilder projects before writing any actual reconciliation logic — initializing the project, wiring the controller, configuring webhooks, setting up cert-manager, writing a Tiltfile for iteration.
So I built a Claude Code plugin that automates the repetitive setup and guides the full operator lifecycle via slash commands.
It wraps Kubebuilder and related tooling — it doesn’t replace them.
Available commands:

  /k8s:prereqs - Checks and installs Go, Kubebuilder, kind, kubectl, Kustomize, Tilt.

  /k8s:create-cluster - Creates a kind cluster for local development.

  /k8s:create-operator - Scaffolds a controller-runtime operator including: CRD definitions, reconciliation skeleton, RBAC markers, webhook boilerplate, project layout, Tiltfile for live iteration

  /k8s:dev - Starts the Tilt-based dev loop.

  /k8s:verify - Validates CRDs, pods, webhooks, and cluster events.

  /k8s:checklist - Runs a safety and quality checklist before shipping.

The part I care most about is the safety hook.
It uses a PreToolUse hook to block kubectl/helm/kustomize commands unless the current context matches kind-*. This prevents accidental operations against non-local clusters during development — something I’ve personally seen go wrong.
Install:

  claude plugin marketplace add https://github.com/Sagart-cactus/claude-k8s-plugin

  claude plugin install k8s@sagart-devtools

GitHub: https://github.com/Sagart-cactus/claude-k8s-plugin
I built this partly to learn Claude Code’s plugin system, and partly because I needed it while building OptiPod (a GitOps-safe Kubernetes resource rightsizing operator).
Happy to answer questions about:
- Claude plugin architecture
- The hook system
- Kubebuilder automation patterns
- or operator lifecycle design.

value: Show HN: Claude plugin to automate Kubebuilder setup


value: Sabrees

value:
Sowbot is an open-hardware agricultural robot designed to close the "prototype gap" that kills most agri-robotics startups and research projects — the 18+ months spent on drivers, networking, safety watchdogs, and UI before you can even start on the thing you actually care about.
The hardware is built around a stackable 10×10cm compute module with two ARM Cortex-A55 SBCs — one for ROS 2 navigation/EKF localisation, one dedicated to vision/YOLO inference — connected via a single ethernet cable.
Centimetre-level positioning via dual RTK GNSS, CAN bus for field comms, and real-time motor control via ESP32 running Lizard firmware.
Everything — schematics, PCB layouts, firmware — is under open licences.
The software stack runs on RoSys/Field Friend (for teams who want fast iteration) or DevKit ROS (for teams already in the ROS ecosystem). The idea is that a lab in one country can reproduce another lab's experiment by sharing a Docker image.
Current status: the Open Core brain is largely fabricated, the full-size Sowbot body has a detailed BOM but isn't yet assembled, and we have two smaller dev platforms (Mini and Pico) in various stages of testing.
We're a small volunteer team and we're looking for contributors — hardware, ROS, firmware, docs, whatever you can offer.
The best place to start is our Discord: https://discord.gg/SvztEBr4KZ — we have a weekly call if you'd prefer to just show up and chat.
GitHub: https://github.com/Agroecology-Lab/feldfreund_devkit_ros/tre...

value: Show HN: Sowbot – Open-hardware agricultural robot (ROS2, RTK GPS)

author: Sabrees


value: laurentenhoor

value: I built DevClaw, an OpenClaw plugin for managing multiple dev projects from my phone without losing oversight or control.<p>It's simple but opinionated: issues are your backlog, PRs are your deliverables, Telegram groups are your project rooms. That's it. No dashboards, no custom UI, no new tools to learn. You write issues, DevClaw picks them up, assigns the right developer tier based on complexity, writes the code, opens PRs, runs QA review, and loops back on failures — all automatically.

value: Show HN: Stop Babysitting Your Agents – Let Them Work as a Team

author: laurentenhoor


value:
I built vexp to solve two problems I kept hitting with AI coding agents (Claude Code, Cursor, etc.):
1. Token waste: agents read entire files linearly to understand a codebase. On a medium TypeScript project, a single query was consuming ~18k tokens of context when only ~2.4k were relevant.
2. Session amnesia: every new session starts from zero. The agent re-reads the same files, re-discovers the same architecture, re-traces the same dependencies.
How it works:
- tree-sitter parses the codebase and extracts symbols + relationships into a SQLite dependency graph
- When an agent requests context, vexp serves a token-budgeted "capsule" containing only the relevant nodes: the target function, its callers, imported types, cross-file dependencies — not entire files
- Session memory: every agent interaction is auto-captured as an observation linked to specific graph nodes. Next session, relevant observations surface automatically via MCP
- Staleness detection: when code changes, observations linked to modified symbols are flagged stale. The agent sees "I learned X about this function, but it's changed since then"
- Cross-repo: detects API contracts, shared types, and env contracts across multiple repos, all locally via workspace config
Architecture: native Rust binary + SQLite. No cloud, no embedding model, no external dependencies. Talks to agents via MCP (Model Context Protocol) stdio. Currently distributed as a VS Code extension but the MCP server is standalone.
The dependency graph is fully deterministic — AST structural analysis, not vector embeddings. Code relationships are facts (imports, calls, type references), not similarity scores. This means zero hallucination risk in the retrieval layer and trivial staleness detection (you know exactly which nodes changed).
Hybrid search for memory: FTS5 BM25 + TF-IDF cosine similarity + recency decay (7-day half-life) + graph proximity scoring - staleness penalty.
Supports 11 languages, 12+ MCP-compatible agents. Free tier includes context capsules + all session memory tools.
https://vexp.dev
Happy to discuss the architectur; the most interesting design decisions were around the scoring algorithm for pivot node selection and how to link observations to graph nodes without making the staleness detection too aggressive or too lenient.

value: Show HN: Vexp – Local-first context engine for AI coding agents


value: MbBrainz

value:
I built TTSLab — a free, open-source tool for running text-to-speech and speech-to-text models directly in the browser using WebGPU and WASM.
No API keys, no backend, no data leaves your machine.
When you open the site, you'll hear it immediately — the landing page auto-generates speech from three different sentences right in your browser, no setup required.
You can then try any model yourself: type text, hit generate, hear it instantly. Models download once and get cached locally.
The most experimental feature: a fully in-browser Voice Agent. It chains speech-to-text → LLM → text-to-speech, all running locally on your GPU via WebGPU. You can have a spoken conversation with an AI without a single network request.
Currently supported models:
- TTS: Kokoro 82M, SpeechT5, Piper (VITS)
- STT: Whisper Tiny, Whisper Base
Other features:
- Side-by-side model comparison
- Speed benchmarking on your hardware
- Streaming generation for supported models
Source: https://github.com/MbBrainz/ttslab (MIT)
Feedback I'd especially like:
1. How does performance feel on your hardware?
2. What models should I add next?
3. Did the Voice Agent work for you? That's the most experimental part.
Built on top of ONNX Runtime Web (https://onnxruntime.ai) and Transformers.js — huge thanks to those communities for making in-browser ML inference possible.

value: Show HN: TTSLab – A voice AI agent and TTS lab running in the browser via WebGPU

author: MbBrainz


value: synctek

value:
SpecterQA is an open-source CLI for behavioral testing. Instead of writing test scripts with selectors, you define personas (YAML) and journeys (goals). The engine launches a real browser via Playwright, screenshots the page, sends it to Claude's vision model, and the AI decides what to click/type/scroll. Loop until done or stuck.
The idea: test scripts break when markup changes. Vision-based tests break when the UX actually breaks.
Personas have attributes like technical comfort, patience, and role that shape navigation behavior. A "frustrated non-technical admin" navigates differently than a "power user developer."

  pip install specterqa
  specterqa init
  specterqa run -p demo

Cost: ~$0.30-$3.00/run depending on journey length. Built-in budget caps. Requires Anthropic API key.
Previously called GhostQA — we rebranded after discovering ghostqa.com exists as an AI testing company. Clean break, no confusion.
GitHub: https://github.com/SyncTek-LLC/specterqa
MIT license. Alpha (v0.3.0). Feedback welcome.

value: Show HN: SpecterQA – AI personas test your web app, no scripts needed

author: synctek


value: Beefin

value: Show HN: Agent Multiplexer – manage Claude Code via tmux

author: Beefin


value: chepy

value: Show HN: Mato – a Multi-Agent Terminal Office workspace (tmux-like)

author: chepy


value:
Hey HN! I built sc-research — an open source skill that gives AI coding assistants (Claude Code, Cursor, Windsurf) the ability to do social media analysis.
You just ask your agent something like "What do people think about product X?" or "What's trending this week?" and it goes out, pulls live discussions from Reddit and X, and comes back with structured results + interactive dashboards.
It can do rankings, sentiment breakdowns, trend timelines, controversy mapping, and topic discovery — all backed by real quotes from real people.
How it works: it pulls live discussions from Reddit (via OpenAI) and X (via xAI/Grok), classifies what kind of analysis your question needs (ranking, sentiment, trend, etc.), runs the analysis, and outputs structured JSON + an interactive dashboard. Install is just "npm install -g sc-research" and "sc-research init --ai claude".
Stack: Bun/Node, OpenAI + xAI APIs, Zod, Vite + TS for the dashboard.
Happy to answer any questions!

value: Show HN: sc-research – Social media analysis skill for AI agents (Reddit and X)


value: danalec

value: Show HN: C99 implementation of new O(m log^(2/3) n) shortest path algorithm

author: danalec


value: chenhunghan

value:
I'm preparing for a half marathon and wanted a way to have a real conversation with an AI about my training — using my actual Garmin data.
So I built a MCP App that connects your Garmin watch to Claude Desktop/ChatGPT Desktop.
Unlike a typical MCP server that only gives the LLM access to data, MCP Apps can also render UI. That means when you ask Claude about your training, it doesn't just reply with text — it shows interactive charts and visualizations right inside the conversation.
Ask "Plan my next workout" and Claude analyzes your recent activity, training load, and recovery using the latest model — then creates a structured workout and pushes it to your Garmin calendar. Ask "Am I ready to train today?" and see a training readiness breakdown with scores for sleep, HRV, recovery, and stress — all visual, all interactive.
What you can explore:
- Daily health charts: steps, heart rate, sleep stages, stress, body battery, HRV
- Workout analysis: pace splits, HR zones, training effect
- Fitness trends: training readiness, training load, VO2 Max, race predictions
- Workout planning: create, edit
Privacy was important to me — no intermediate server, no data collection. Your Garmin credentials are handled in a secure login form that the LLM never sees. Data flows directly between your machine and Garmin's API. Tokens stay local.
Install: download the .mcpb from Releases, drag into Claude Desktop/ChatGPT Desktop, done.
MIT licensed.
GitHub: https://github.com/chenhunghan/garmin-mcp-app

value: Show HN: MCP Apps for marathon runners, coaching with interactive charts

author: chenhunghan


value: sundancegh

value:
I got tired of being the human middleware between my AI agent and my own codebase rules.
Every session my agent would start fresh with no memory of the architectural decisions we had made. It would confidently ignore naming conventions, bypass security patterns, and quietly undo things I had spent weeks getting right.
I tried CLAUDE.md, .cursorrules, plan files, task files. They all have the same ceiling: the agent treats them as suggestions, context windows bury them as sessions grow, and there is zero enforcement when they get violated. The prompt is the spec in AI-native development, and right now that spec disappears every time the chat closes.
MarkdownLM is my attempt to fix the layer below the agent, not by writing better prompts, but by treating your team's engineering rules as infrastructure.
How it works:
Your knowledge base lives in structured categories: architecture decisions, security constraints, business logic, naming conventions, whatever your team actually cares about. When an agent makes a call, MarkdownLM uses semantic embeddings to pull only the relevant rules rather than flooding the prompt with your entire knowledge base. Out of 500 documents, the agent sees the 3 that matter for this specific task. That keeps context focused, tokens low, and the agent from getting lost in irrelevant rules.
Before generation, relevant context is injected. After generation, a validation gate checks the output against your rules and blocks violations with a receipt showing the specific rule, the reason, and the smallest suggested fix. When the agent hits something ambiguous with no rule coverage, it does not guess and ship. It stops, flags it as a gap, and routes it to whoever you have designated as the decision maker for that category.
Everything is MCP-native so it works across Cursor, Claude Code, and any MCP-compatible host without changing your workflow. The CLI lets you manage your knowledge base from the terminal like code: clone, diff, push, sync across your team.
What I learned building it:
The interesting part was realizing the cost structure. Using Google's text-embedding-004 at $0.15 per million input tokens to retrieve the right 3 documents means the retrieval layer costs fractions of a cent per call. That cheap embedding lookup replaces what would otherwise be a 100k-token prompt. Lower cost and better results because focused context beats large context almost every time.
The gap resolution feature surprised me most in practice. Teams do not just have rule violations. They have rule gaps, situations the agent encounters that nobody thought to write a rule for yet. Surfacing those gaps as actionable items rather than silent guesses turned out to be as useful as the enforcement itself.
Current state:
Public beta. BYOK is free, no credit card. Your code never touches our servers. The CLI and MCP server are open source on GitHub. Will stay free for individuals because I know the pain.
Site: https://markdownlm.com
CLI: https://github.com/MarkdownLM/cli
MCP: https://github.com/MarkdownLM/mcp
I am the solo founder. Brutal feedback is the only feedback I want.

value: Show HN: MarkdownLM – Stop being the human middleware for your AI agent

author: sundancegh


value: ChesterHsu

value: Show HN: 412 deterministic modules so AI agents stop hallucinating commands

author: ChesterHsu


value: arajnoha

value:
Current generation lives in apps that evolve around the profile. That one link there is their gateway to the well curated life. Here is a minimalistic and phone-first online store platform that is actually free to start and run. Only fee applied is on successful sale.
I tried to balance the customization options and settigns with simplicity in one single dashboard. Take a look!

value: Show HN: Free ecommerce platform for link-in-bio people

author: arajnoha


value: sunnynagra

value:
https://trading.snagra.com
It’s an autonomous trading system that does more than signal generation. It runs an end-to-end loop:
- market/news scanning
- opportunity discovery
- risk checks (position concentration + stop logic)
- execution through Alpaca
- rationale logging for each decision
- daily/weekly strategy evolution
The part I think HN might find interesting: the orchestration page
The orchestration page is where you can see the system as a pipeline, not a black box. It shows:
- scheduled jobs (pre-market, open, intraday monitor, close, weekly review)
- which stage is running and what each stage does
- escalation flow (scout → deeper orchestrator)
- status + outputs of each run
- links between analysis, action, and logged rationale
I built this because most “AI trading bots” show entries/exits, but not the decision process.
Core design choices
- Adaptive strategy layer (not locked to one style)
- Two-stage orchestration: fast scout + deeper decision pass
- Deterministic guardrails for risk/mechanical actions
- Public audit trail in activity feed (analysis + rationale + evolution logs)
- Suggestion workflow: people can submit ideas; system reviews before adoption
Tech stack (current)
- OpenClaw agent orchestration
- GPT-5.3 Codex for active model workflows
- Alpaca for broker/data execution
- Python scripts for screening/intel/risk/execution
- FastAPI + React site for visibility
What I’d love feedback on
1. Orchestration UX: what would make the pipeline easier to inspect/debug?
2. Failure mode design: what should be surfaced more clearly?
3. Governance: how would you structure safe community suggestions for a system like this?

value: Show HN: A self-evolving trading system with transparent orchestration

author: sunnynagra


value: cannoneyed

value:
Hey HN,
As NYC wakes up to the largest blizzard in years, I’d like to share [isometric.nyc/snow](http://isometric.nyc/snow) - a wintry mix of the original isometric pixel map of NYC .
This work builds on the original isometric.nyc ideas but aims to increasingly automate the process of generating the tiled images. I’ve written up a follow-up addendum at [cannoneyed.com/projects/isometric-nyc\#snow](http://cannoneyed.com/projects/isometric-nyc#snow) that describes some of this work, but the tl;dr is:
* ensuring that training data and generations are color balanced / normalized goes a long way for consistency (duh)
* augmenting water with a crosshatch pattern allowed the model to learn what it was instead of hallucinating (interesting!)
* dramatically increasing inference throughput on [modal.com](http://modal.com) meant I could generate 10s of thousands of tiles in a few hours at very little cost, allowing me to experiment much more rapidly
This project continues to be a lot of fun, but I’m now mostly focusing on the agentic workflows that power this kind of ambitious generation at scale. Can’t wait to share more soon.

value: Show HN: isometric.nyc/snow

author: cannoneyed

title: Show HN: isometric.nyc/snow


value: fyskij

value: Show HN: Talpa – Datasette-powered reading stats dashboards for Kobo and Kindle

author: fyskij


value: himanshuDS

value: Show HN: AI-context-bridge – Save AI coding context across tools via Git hooks

author: himanshuDS


value: FrogSnot

value:
I built Sunder because I was tired of heavy, telemetry-bloated music clients that take 500MB of RAM just to play a song. Sunder runs with a 15MB binary and a tiny memory footprint.
The Tech Stack:
• Tauri v2 + Svelte 5.
• Dedicated Rust audio thread (rodio/symphonia) to prevent UI-stutter.
• 16ms state-sync between Rust and the UI for a 60fps feel.
• Local SQLite FTS5 cache for instant search.
I'm a 17-year-old developer. I’m obsessed with 'Speed as a Luxury'. My other project, HardBore, achieves 709k items/sec directory crawls because I believe desktop software should be instant.
I’d love to hear your thoughts on the audio sync implementation or how I can push the binary size even lower!
https://github.com/FrogSnot/Sunder

value: Show HN: Sunder – A 15MB Rust/Tauri music player for YouTube without the bloat

author: FrogSnot


value:
An alternative to NVIDIA Broadcast for Linux, on top of the NVIDIA Maxine VideoFX SDK.
It features locally processed video effects: background blur, background replacement, background removal.
It has on-demand video processing, so you can leave it running in the background with minimal overhead, it will only use your device camera when the virtual camera is used. Useful for meetings, recording videos, streaming.
Backstory: This idea started in 2023 when I was in 11th grade and needed to attend some online programming competitions, but wanted to use Linux in which I had a way faster development workflow. I found out that NVIDIA actually published the Maxine VideoFX SDK on which Broadcast was built, and example sources along with it, so it wasn’t very hard to implement something that worked (back then it was just a distrobox in which I manually started the effect I wanted in the cli). It worked great, but the competitions ended and I completely forgot about it. Recently, I remembered about it, and thought this is a great opportunity to build an UI around it, especially with the help of modern designing tools like v0 and friends.
Would love to hear any feedback, and I hope some of you find it useful!

value: Show HN: Blucast – An Nvidia Broadcast Alternative for Linux


value: joemasilotti

value: Show HN: What I've learned from shipping 25 mobile apps

author: joemasilotti


value: WolfOliver

value: Show HN: Yet Another Firebase Alternative

author: WolfOliver


value: plyra

value:
AI agents are being deployed to take real-world actions — file operations,
API calls, database writes. There's no standard safety layer between the
LLM's decision and execution.
plyra-guard is that layer. It intercepts every tool call before it runs,
evaluates it against a policy, and blocks, logs, or escalates.
@guard.wrap
def delete_file(path: str) -> str:
os.remove(path)
delete_file("/tmp/report.txt")  # ALLOW — 0.3ms
delete_file("/etc/passwd")      # BLOCK — "System config is off-limits"
Key things:
Policy engine (YAML or Python rules: allow / block / escalate)
Works with LangGraph, AutoGen, CrewAI, LangChain, plain Python
Sub-2ms in-process evaluation, no network hop
Every action logged, ships to OTEL or Datadog
Built-in dashboard at localhost:8765
The LangGraph integration has a non-obvious wrinkle: ToolNode uses
internal state tracking that breaks transparent tool wrapping. We ended
up building a custom guarded_tool_node pattern — cleaner anyway.
217 tests. Python 3.11–3.13. Apache 2.0.
Docs: https://plyraai.github.io/plyra-guard
─────
HN TIPS:
Reply to every comment within 1 hour
If someone critiques: "Good point — here's how we handle X" beats defending
One genuine thread > ten upvotes for front page velocity

value: Show HN: Plyra-guard – intercepts AI agent tool calls before execution

author: plyra


value: kemyd

value: Drop in a prompt and watch leading AI models compete on taste, layout, and creativity.<p>Unlike Design Arena, our tool lets you watch projects being generated live, choose the best result, and refine it visually before exporting directly to Next.js, Laravel, or a WordPress theme.

value: Show HN: Live AI Design Benchmark

author: kemyd

title: Show HN: Live AI Design Benchmark


value: pvpv

value:
Hey HN, we are releasing IRPAPERS to answer a highly pragmatic question: when building a RAG pipeline over PDFs, should you OCR the text or just embed the raw page images?
Processing PDFs in production usually involves stringing together brittle OCR heuristics. While recent multimodal embeddings (like ColModernVBERT or ColPali) allow you to skip OCR entirely and retrieve directly from visual layouts, we wanted to measure if the computational overhead is actually worth the utility.
The short answer: Transformer-based image pipelines won't be perfect for every use-case, but they fix exactly what OCR breaks.
Here is what we found benchmarking 3,230 pages of dense scientific literature:
Complementary Bottlenecks: Text representations (BM25 + dense vectors) are highly efficient for exact lexical constraints (e.g., finding a specific acronym like "HyDE"). Conversely, image embeddings shine on spatial architecture diagrams and t-SNE plots where OCR serialization just turns into structural garbage.
Multimodal Hybrid Search: Because these failure modes are almost perfectly orthogonal, fusing the two signals gives you the best performance out of the box. By combining them, we pushed top-1 recall to 49% (beating text alone at 46%).
The Memory Constraint: Late-interaction image embeddings produce thousands of vectors per page, creating a massive storage bottleneck. To address this need, we evaluate MUVERA encoding. Under the hood, this compresses multi-vector representations into a single fixed-dimensional encoding via SimHash, allowing you to use standard HNSW indexing without the paralyzing memory overhead.
In practice, if you are building a RAG workflow today, text-based context still provides higher downstream utility for the actual generation step (0.82 vs 0.71 alignment). Instead of picking one modality and dealing with its blind spots, start with hybrid text search as a sensible default, and inject multi-vector image embeddings to catch the visual edge-cases.
We’ve open-sourced the benchmark and the evaluation recipes:
Paper https://arxiv.org/abs/2602.17687
IRPAPERS dataset on HuggingFace at huggingface.co/weaviate/IRPAPERS and GitHub
at github.com/weaviate/IRPAPERS
Our experimental code is also available on GitHub at
github.com/weaviate/query-agent-benchmarking
Happy to answer any questions about the evaluation pipeline, the cold start problem of visual benchmarks, or the specific retrieval trade-offs we saw.

value: Show HN: Irpapers – Visual embeddings vs. OCR trade-offs in scientific PDFs

author: pvpv


value: mcone

value: Show HN: Imgur for Markdown

author: mcone

title: Show HN: Imgur for Markdown


value: nirvanist

value: Show HN: Next.js Bot Prerender Middleware (Page Replica and Vercel)

author: nirvanist


value: marcosinghof

value:
I built this because I wanted a clean recipe browsing experience without ads, life stories, or SEO bloat. However, I still needed accurate nutrition info. Tastebuds AI calculates nutrition by mapping every ingredient to the USDA Food Data Central database, so the numbers are actually trustworthy.
You tell it your dietary restrictions, cuisine style (healthy, easy, adventurous, etc.), ingredients you dislike, and what kitchen equipment you have. It then generates ideas and subsequently a full recipe with ingredients, step-by-step instructions, an AI-generated image, and an accurate macro breakdown.
The app is still fresh so I can pivot in any direction — would love feedback, especially from people tracking macros or managing dietary restrictions where accuracy matters.

value: Show HN: Tastebuds AI – recipe generator with USDA-backed nutrition data

author: marcosinghof


value: recvonline

value: Show HN: Brag Frog – The brag doc that builds itself from GitHub, Jira and Co

author: recvonline


value:
We’ve been building BaitAI, a conversational AI interviewer for interview practice and async candidate screening.
AI interviews can feel like filling out a questionnaire - you answer a static question and get generic feedback. Real interviews are conversational: interviewers ask follow-ups and adapt based on what you say.
BaitAI runs interview-style sessions where the AI asks questions follows up based on your responses probes your reasoning and evaluates how you communicate your approach and give a detailed report in seconds after interview ends.
We’ve also started experimenting with interview artifacts so the AI can evaluate more than just text during a session.
Right now ,a code editor is built into the interview flow is included for LLD interview.

value: Show HN: BaitAI – Conversational AI interviews with realtime interview artifacts


value: corefiredrill

value: Show HN: Find Local Business Leads

author: corefiredrill

title: Show HN: Find Local Business Leads


value: kalpitdixit

value: Show HN: Unlock the best engineering knowledge in papers for your coding agent

author: kalpitdixit


value: yding

value:
Coded this up on a trip to Vegas. The only free basic strategy practice app that uses dynamic programming to calculate both the house edges and the expected value loss of deviating from basic strategy.
Code: https://github.com/yisding/twentone

value: Show HN: Blackjack Basic Strategy Practice with DP Edges

author: yding