value: hankimis

value:
I kept running into the same problem with AI-generated frontend code: most tokens go to boilerplate, and the AI can never pick a consistent pattern. So I built a language where there's only one way to write things.
0x is indentation-based (think Python), declarative, and compiles to React JSX, Vue 3 SFC, or Svelte 5. A counter component is 18 lines in 0x vs 96 in production React.
page Counter:
  state count: int = 0
  fn increment():
    count += 1
  layout col gap=16 padding=24 center:
    text "{count}" size=4xl color=cyan
    button "+1" style=primary -> increment()
The compiler is ~3K lines of TypeScript, zero dependencies. Pipeline: Lexer → Parser → AST → CodeGen (one pass per target). It handles state, derived values, typed variables, functions, flexbox layouts, control flow (if/elif/else, each, match), lifecycle hooks, API calls with loading/error states.
I chose indentation-based syntax because it's the most token-efficient structure I could find. No curly braces, no semicolons, no JSX closing tags, no import boilerplate. For an LLM, fewer structural decisions = fewer hallucinations.
There's a built-in MCP server so Claude and Cursor can compile inline. Also works as a library:
import { compile } from '0x-lang/compiler';
const result = compile(source, { target: 'react' });
I'm curious about two things:
Is "designed for AI" a real market, or is this too niche?
For folks who've built compilers — any obvious mistakes you see in the architecture?
Website: https://0xlang.com
GitHub: https://github.com/hankimis/0x-lang
npm: https://www.npmjs.com/package/0x-lang

value: Show HN: 0x – A language that compiles to React, Vue, and Svelte (80% less code)

author: hankimis


value: JupyterPS

value:
I implemented neural networks and Q-learning in pure PowerShell - no Python, TensorFlow, or external dependencies.
Why? I teach IT professionals who live in PowerShell. Python ML examples don't resonate. Building from scratch teaches fundamentals better than using black-box libraries.
What's included:
- Neural networks: Backpropagation, gradient descent, multiple activation functions
- Q-learning agents: Experience replay, epsilon-greedy exploration, reward shaping
- Environment simulation: Market competition, resource optimization
- Real-time visualization dashboards
Technical details:
- Pure PowerShell (classes, no C# interop)
- ~3000 lines of code
- Compatible with PowerShell 5.1+ (Windows/Linux/Mac)
- Available on PowerShell Gallery
Example use case: Q-learning agent learns to build ASCII castles through trial-and-error. Agent receives aesthetic rewards and discovers patterns without hardcoded rules.
Practical applications:
- IT automation that adapts to patterns
- Predictive maintenance from log analysis
- Resource scheduling optimization
- Anomaly detection in enterprise systems
I know this isn't production ML (Python/PyTorch are better for that), but it's valuable for:
1. Teaching ML concepts to non-Python developers
2. Understanding algorithms by implementing them
3. PowerShell-native automation that learns
GitHub: https://github.com/JupyterPS/VBAF
PowerShell Gallery: Install-Module VBAF
Happy to answer questions about the implementation or design decisions.

value: Show HN: VBAF – Machine Learning framework built in pure PowerShell

author: JupyterPS


value: Mapika

value: Show HN: Portview – a diagnostic-first port TUI (Rust, cross-platform)

author: Mapika


value: Show HN: Why 'provably fair' RNGs aren't trust-less, and how to fix them


value: renatomarinho

value: GitScrum MCP Server brings Model Context Protocol support to GitScrum, enabling Claude, GitHub Copilot, Cursor, and other AI assistants to manage your tasks, sprints, time tracking, user stories, epics, and more.<p>Built with TypeScript. Currently has 1 star – would love your feedback and contributions!

value: Show HN: GitScrum MCP Server for Claude and AI Assistants

author: renatomarinho


value:
Hi HN,
I built Pingui Alert because I kept overengineering alerting for small projects.
I didn’t need dashboards, charts or complex configs — I just needed a Telegram
message when something important broke.
Pingui Alert is:
- One API call → Telegram alert
- Open source & self-hostable
- Queue-based (Redis)
- No log storage, no PII
It’s meant for things like:
payment failures, disk space alerts, failed backups, security events.
There’s a public bot with a small daily limit, or you can self-host it.
GitHub: https://github.com/juanvidev1/pingui-alert
Live: https://pingui-alert.dev
I’d really appreciate technical feedback — especially what feels unnecessary
or what you’d simplify even more.

value: Show HN: Pingui Alert – dead simple Telegram alerts from your code


value: taoh

value:
Hi HN,
SOC 2 audit prep costs 20K/year, so I wrote a Agent skill to automate most of it. It goes beyond policy generation from templates by leveraging the abilities to access your codebase:
- asks contextual questions about your company and specifics about each policy
- scans your source code
- uses aws, azure-cli, gcp to check your cloud infra
- writes shell scripts to fetch configs from your SaaS: Okta, Datadog, PagerDuty, Jira etc.
As a result you get:
- A set of policy documentation tailored to your company
- All evidences are automatically versioned with your repo
- Automatic evidence collection through Github Workflow Actions
- Leverage Claude Code to add new integration scripts easily
- No secrets leave your environment
This is targeted at small companies and startups who’d rather spend an afternoon with an agent than $20K/year on a compliance platform. It doesn’t replace the auditor and various aspects of compliance platforms, but handles a good trunk of the grunt work for free.
Some design choices I made: Each evidence collection script is a readable shell you can run locally: make it easy to unit test each script rather than relying on runtime agents. Organize frameworks & integrations so it’s easy to add new ones. Progressive Disclosure: only load context when needed
Repo: https://github.com/screenata/compliance-automation
Demo Video: https://www.youtube.com/shorts/EevpE6bKwhA
I'd love your feedback on:
If you’ve been through SOC 2, what controls were hardest to evidence?
PRs with new frameworks, evidence collection scripts with your SaaS tools
What would you like to see next

value: Show HN: Open-source agent skill that automates SOC 2 audit prep

author: taoh


value:
CodeSnip is a cross‑platform snippet manager and local code runner built with Avalonia UI.
It includes local script execution (Shell, C#, F#, Python, PHP, Lua, Ruby, Node.js, PowerShell, Java/JShell), Compiler Explorer integration, and an advanced editor for editing XSHD highlight definitions.

value: Show HN: CodeSnip – Cross‑Platform Snippet Manager and Code Runner


value: puntofisso

value:
A friend who's a corporate photographer came to me with an interesting problem: aligning multiple portrait photos for team pages, yearbooks, directories, so that faces are consistently positioned.
Fundamentally, when you take dozens of photos in a day, they are likely to be all slightly different in terms of crop.
As I had done some work with facial feature recognition, my friend asked if the same tech could be used for his problem... and here's why FaceCrop came to be :-)
How does it work:
- drop in your photos
- FaceCrop detects faces using face-api.js or tracking.js
- FaceCrop suggests crops
- fine-tune the crops individually or globally
- export the crops in a .zip file.
To note, everything runs client-side on the browser: no uploads, no server-side, no accounts. It was mostly developed using some code I had from a previous project and some Claude Code.
Would welcome constructive feedback most importantly on the crop adjustment UI/UX, but also on the detection accuracy, suggested crop shape, etc.
http://facecrop.puntofisso.net/

value: Show HN: FaceCrop – Align and crop portrait photos with face detection

author: puntofisso


value: cgfloat

value:
Hi HN!
I work on an analytical database engine, and I spend a lot of time trying to understand the structure of Apache Parquet files (row groups, column chunks, data pages, encodings, etc.).
I feel like existing tools for this job such as parquet-tools or pyarrow are cumbersome to use and for anything beyond the basics you end up writing custom code. Datanomy contains some more info, but still requires installing a CLI. Some databases like DuckDB also have a feature to query the metadata, but that means writing SQL for every little thing you want to check, and the output is still text.
I wanted something I could just drop a file into, and immediately see the structure visualized — so I built Parquetastic, a browser-based visual Parquet metadata inspector tool.
What it does:
- Visualizes the full Parquet file structure: row groups, column chunks, pages (if your file has a page index), encodings, compression, statistics
- Shows key specs at a glance without writing any code or queries (e.g., footer size, page index size)
- Runs entirely in the browser — the data never leaves your device
- No download, no installation, no signup
Live demo: https://parquetastic.dev
GitHub: https://github.com/FlorianPfisterer/parquetastic
I'd love your feedback, especially from anyone who regularly works with Parquet files!
Disclaimer: This project was fully built in my free time and has nothing to do with my employer.
And before you ask: Yes, this was mostly vibe-coded (or rather "agentically engineered"). Without these tools, I wouldn't have had the time to build it!

value: Show HN: Parquetastic – a browser-based Parquet metadata inspector

author: cgfloat


value: mmsols

value:
It's a SwiftUI app (macOS 14+) that wraps the Homebrew CLI and adds features I've always wanted:

  - Browse, search, install, and uninstall formulae and casks with a 3-column native interface
  - Bulk operations – select multiple packages to upgrade or remove at once
  - CVE/vulnerability scanning – checks installed packages against the OSV database
  - Dependency tree visualization – see what depends on what before removing things
  - Orphaned dependency cleanup – find and remove packages nothing depends on anymore
  - Duplicate app detection – spots apps installed from both Homebrew and /Applications
  - Third-party app update scanning – detects Sparkle/GitHub updates for non-Homebrew apps too
  - Curated collections – one-click install bundles for web dev, data science, DevOps, etc.
  - Services management – start/stop/restart brew services from the GUI
  - Scheduled maintenance – auto-run cleanup and brew doctor on a schedule
  - Mac App Store integration (via mas CLI)
  - Menu bar icon with background update checks and notifications

  Available via brew install --cask taphouse or direct download. Localized in 6 languages.

  Currently at v1.4.8 (50 builds in). I'd love feedback on what else would be useful.

https://taphouse.multimodalsolutions.gr

value: Show HN: Taphouse – A Native macOS GUI for Homebrew

author: mmsols


value: Sportinger

value:
GitHub: https://github.com/Sportinger/MasterSelects
I built this Browser-based video compositor with a GPU-first architecture. No Canvas 2D in the rendering path — video textures go in as texture_external (zero-copy), compositing runs through a ping-pong WGSL shader pipeline, and export captures frames directly from the GPU canvas via WebCodecs.
39 GPU effects, 37 blend modes, nested compositions, keyframe animation with bezier curves, vector masks, 10-band live EQ, video scopes, and AI-driven editing via GPT function calling. 13 production dependencies. The compositor, all shaders, timeline, audio mixer, mask engine, and export pipeline are built from scratch.
I'm a video artist, not a developer. Built this entirely with Claude. Things break, but when it works, it works.
Chrome/safari  with WebGPU required. Firefox and webGPU have problems.

value: Show HN: Browser-based video compositor built on WebGPU

author: Sportinger


value: wspycnews

value:
Hi HN,
I've put together a collection of open-source Shopify sections (Liquid, CSS, JS) that can be added to themes.
I built this because I found that while Shopify is great, standard themes often lack specific sections, and custom development can be expensive for small merchants. I wanted to create a repository of high-quality, copy-pasteable sections that developers can use to speed up their workflow or merchants can use to enhance their stores without apps.
I’d love to hear your feedback on the code structure or requests for other common sections that are usually missing from default themes.

value: Show HN: Open-source Liquid sections for Shopify themes

author: wspycnews


value: Show HN: Murmur – open-source cron daemon for coding agents


value: darccio

value:
Lately, while experimenting with agentic coding, I kept running into the same pain point: committing generated code cleanly. Quick prototypes often turn into large diffs that are hard to review and even harder to split into sensible commits.
After watching a FOSDEM talk on efficient Git workflows [0], I started exploring the idea of “atomic commits” for Go. The result is Darna.
Darna is a small CLI tool (usable as a Git hook) that validates whether your staged changes form a valid, working fileset. It works down to the line level, so partial staging is fully supported, and it can also tell you which additional files need to be staged (as whole files) to make a commit truly atomic.
If you’re dealing with large diffs, partial staging, or AI-assisted code generation, this might be useful for you too. For extra confidence: all commits in the repo are validated by Darna itself, and the commit messages were reviewed (not auto-generated) with help from Claude Code.
Feedback very welcome.
0: https://fosdem.org/2026/schedule/event/3VNNBK-efficient-git-...

value: Show HN: Darna – Atomic commit validator for Go

author: darccio


value: pierreseck

value: Show HN: GPU ROI simulator based on token usage and model architecture

author: pierreseck


value: detroitwebsites

value:
I got tired of paying $15-50/month to sign PDFs, so I built a free alternative.
How it works: Upload PDF, draw or type your signature, place it, download. Done.
No account required. No document limits. No watermarks. No "you've used your 3 free signatures" gotchas.
Monetized through ads (same model as Photopea).
Tech: Node.js + Express, pdf-lib for manipulation, vanilla JS frontend. Processing happens client-side for privacy.
Happy to answer questions about the implementation or business model.

value: Show HN: Sign Any PDF Free – No account, no watermarks, no limits

author: detroitwebsites


value:
Recently I was trying to use an MCP server to pull data from a service, but hit a limitation: the MCP didn't expose the data I needed, even though the service's REST API supported it. So I wrote a quick CLI wrapper around the API. Worked great, except Claude Code had no structured way to know what my CLI does or how to call it. For `gh` or `curl` the model can learn from the extensive training data, but for a tool I just wrote, it was stabbing in the dark.
MCP solves this discovery problem, but it does it by rebuilding tool interaction from scratch: server processes, JSON-RPC transport, client-host handshakes. It got discovery right but threw out composability to get there. You can't pipe one MCP tool into another or run one in a cron job without a host process. Pulling a Confluence page, checking Jira for duplicates, and filing a ticket is three inference round-trips for work that should be a bash one-liner. I also seem to endlessly get asked to re-login to my MCPs, something `gh` CLI never asks me to do.
I think the industry took a wrong turn here. We didn't need a new execution model for tools, we needed to add one capability to the execution model we already had. That's what Model Tools Protocol (MTP) is: a spec for making any CLI self-describing so LLMs can discover and use it.
MTP does that with a single convention: your CLI responds to `--mtp-describe` with a JSON schema describing its commands, args, types, and examples. No server, no transport, no handshake. I wrote SDKs for Click (Python), Commander.js (TypeScript), Cobra (Go), and Clap (Rust) that introspect the types and help strings your framework already has, so adding `--mtp-describe` to an existing CLI is a single function call.
I don't think MCP should disappear, so there's a bidirectional bridge. `mtpcli serve` exposes any `--mtp-describe` CLI as an MCP server, and `mtpcli wrap` goes the other direction, turning MCP servers into pipeable CLIs. The ~2,500 MCP servers out there become composable CLI tools you can script and run in CI without an LLM in the loop.
The real payoff is composition: your custom CLI, a third-party MCP server, and jq in a single pipeline, no tokens burned. I'll post a concrete example in the comments.
Try it:

  npm i -g @modeltoolsprotocol/mtpcli && mtpcli --mtp-describe

I know it's unlikely this will take off as I can't compete with the great might of Anthropic, but I very much welcome collaborators on this. PRs are welcome on the spec, additional SDKs, or anything else. Happy building!
Spec and rationale: <https://github.com/modeltoolsprotocol/modeltoolsprotocol>
CLI tool: <https://github.com/modeltoolsprotocol/mtpcli>
SDKs: TypeScript (<https://github.com/modeltoolsprotocol/typescript-sdk>) | Python (<https://github.com/modeltoolsprotocol/python-sdk>) | Go (<https://github.com/modeltoolsprotocol/go-sdk>) | Rust (<https://github.com/modeltoolsprotocol/rust-sdk>)

value: Show HN: Model Tools Protocol (MTP) – Forget MCP, bash is all you need


value: mbadyl

value:
I built a CLI tool that acts as an AI agent for API testing. Think Claude Code, but for testing APIs – you describe what you want to test, and it autonomously generates test cases, runs them, and reports back.
Written in Go, open source, no GUI. It fits into your existing terminal workflow.
I was tired of manually writing and updating API tests, so I built something that handles that loop for me.
GitHub: https://github.com/Octrafic/octrafic-cli
Feedback welcome.

value: Show HN: Octrafic – AI agent for API testing from your terminal

author: mbadyl


value:
Hello Hacker News,
I’m a computer science student, and I’m building my own programming language called Vela as an learning project.
I'm building Vela to better understand how programming languages work internally: lexer, parser, AST, type systems, and eventually LLVM compilation.
The language is in early stages but already has:
>Custom syntax with type inference
>Parser and basic interpreter
>Pattern matching and pipeline operators
>Roadmap for async/await and parallel execution
I'd especially love feedback on:
>Language design decisions (syntax choices, features)
>Code architecture (currently Python frontend + planned LLVM backend)
>Type system implementation
>What features to prioritize vs. what to cut
Current status: The fundamentals work, but there are definitely bugs and missing pieces. If you've built a language before, your advice would be invaluable.
If anyone wants to contribute, review code, or just point out where I'm doing things wrong, it would help a lot.

value: Show HN: Vela – Modern programming language compiling to native code via LLVM


value:
We launched OpenSink after building AI Agents and noticing some painful patterns: the agents are doing work and it ends up somewhere in Slack, Email, or gets lost. If you use multiple platforms, the agents are scattered around, you can't make changes to them without redeploying and you have low to no visibility regarding what they do.
 Here are the building blocks:
Memory (via Sinks): persistent and searchable memory for agents, that survives restarts.
Sessions: see what an agent did during a run, with a structured timeline.
Input Requests: the agent asks for human input, waits for a response, and continues the execution. Used to build human-in-the-loop agents with low effort.
Configurations: Easily tweak your agent configuration without redeploying the code.
Works with any AI agent platform, or custom code. Launching with docs, examples, and two open-source OpenClaw skills for Memory and Activities.
Website: https://opensink.com
Docs: https://docs.opensink.com
Any feedback is valuable at this point, and thank you for reading so far ^^

value: Show HN: The Control and Memory Layer for AI Agents


value: wmora

value:
Hi HN!
I built a word game last week called Shuffled. It's a daily puzzle where you drag letters around a grid to form the words before running out of moves. It's designed for quick play. Everyone gets the same set of puzzles.
I’d love any feedback on how the difficulty feels and any UX rough edges.

value: Show HN: Shuffled - Daily word puzzle game

author: wmora


value: suprnurd

value: Show HN: AppControl – A Modern Windows Task Manager with History

author: suprnurd


value: sagawafumiya

value:
Hi HN, I built Radiant.
I use Blender's Pie Menu a lot and like how spatial positioning turns into
muscle memory — hold a key, move toward a direction, release. After a while
you stop thinking about it. I wanted that same interaction model in Figma,
VS Code, and the rest of macOS, so I built a system-wide version.
Radiant is a radial and list menu launcher for macOS. You organize actions
into menus, trigger them with a hotkey, and pick by direction or position.
Some design decisions I'd be happy to discuss:
- 8 fixed slots per radial menu — a deliberate constraint for spatial memory.
  More slots = slower selection (Fitts's Law), fewer = not enough utility.
  List menus handle the "I need 20+ items" case.
- Three close modes: release-to-confirm (Blender-style), click-to-confirm,
  and toggle (menu stays open for multiple actions)
- App-specific profiles that auto-switch based on the frontmost application
- Built-in macro system — chain keystrokes, delays, text input, and system
  actions without external tools
Technical details:
- Native Swift/SwiftUI, no Electron
- CGEventTap for global keyboard/mouse monitoring
- Accessibility API for keystroke injection
- All data stored locally in UserDefaults, no telemetry
- JSON config with import/export for sharing presets
URL: https://radiantmenu.com
Would love to hear your thoughts.

value: Show HN: Radiant – Radial Menu Launcher for macOS Inspired by Blender's Pie Menu

author: sagawafumiya


value: gimliapp

value: Show HN: Mouse-tracker – A tiny physics-based mouse tracker (Web Component)

author: gimliapp


value: jbwagoner

value:
I've been running AI agents in production for a music platform and kept hitting the same security gaps — no permission inheritance, no cost controls on nested calls, skills that could execute arbitrary code, no kill switch when things went sideways.
Samma Suit is an open-source security layer that wraps any agent framework with 8 layers:
SUTRA — API gateway with rate limiting
DHARMA — Permission inheritance (parent → child agents)
SANGHA — Skill/tool vetting before execution
KARMA — Cost controls that propagate through subagents
SILA — Immutable audit trail
METTA — Cryptographic identity signing
BODHI — Execution isolation
NIRVANA — Kill switch for runaway agents
Framework-agnostic — works with LangChain, CrewAI, AutoGPT, or raw API calls. Define policies in YAML, Samma Suit enforces them at runtime.
GitHub: https://github.com/onezeroeight/samma-suit
Docs: https://sammasuit.com
The arxiv paper on the front page today (agents violating constraints 30-50% of the time) is exactly why we built this — constraints need to be enforced at infrastructure level, not left to the model.

value: Show HN: Samma Suit – Open-source 8-layer security framework for AI agents

author: jbwagoner


value: Ginsabo

value:
While recovering from gallbladder surgery, I needed Gemini 3 to be reliable—but it kept hallucinating.
I found that as models get smarter, their laziness becomes more "sophisticated." I call this the "Probabilistic Sloth" of 2026. Even with the latest retrieval tools, the model often chooses the path of least resistance, producing plausible-sounding but incorrect output.
Out of frustration, I wrote a system prompt to install a kind of "Will" into the AI. It forces the LLM to split into two roles:
The Drafting Agent: focuses on generating the initial response.
The Ruthless Auditor: focuses strictly on logical error detection and evidence locking.
This creates a friction-based loop—an explicit self-correction step before any output reaches the user. In my tests, it stopped the model from hallucinating about Python libraries that don’t exist.
This is the KOKKI (Self-Discipline) Protocol. It’s not just a prompt; it’s a structured way to force an LLM to catch its own failure modes.
I’ve documented the raw logic on Gist and would love for this community to test it, use it, and tear it apart. I don’t want money; I need brutal feedback to evolve this further.
Feedback welcome.
Even “this was annoying” helps.
The Prompt (Gist): https://gist.github.com/ginsabo/641e64a3dbc2124d1edb0c662be9...

value: Show HN: I wrote a prompt to stop Gemini from hallucinating

author: Ginsabo


value: airowe

value:
I built a tool to end the "save meme → forget where it is → scroll for 5 minutes" cycle.
Snagg lets you grab memes from Reddit, Twitter, Instagram — anywhere — with a right-click. They go into your searchable collection. When you need one, the Chrome extension drops it directly into Discord, WhatsApp, Slack, whatever. No downloading, no tab switching, no digging through your camera roll.
There's also an iOS keyboard so you can insert memes while you're typing.
What's your current meme workflow? Curious how others deal with the chaos.

value: Show HN: Snagg – Clip memes from anywhere, post them instantly

author: airowe


value: hashmakjsn

value:
SNKV is a simple key-value store built on SQLite's B-Tree API. I've just integrated
it with LiteFS to get distributed replication with zero application changes.
The interesting part is how LiteFS works - it sits between your application and
SNKV using FUSE, intercepts WAL writes, and streams them to replica nodes.
The application just sees a regular filesystem. I'm using Consul for leader
election, but LiteFS also supports static configuration.
Setup guide with working code:
https://github.com/hash-anu/snkv/blob/master/litefs_setup_gu...
Verified with 10MB of data replicating correctly across nodes. The guide
includes architecture diagrams and both writer/reader programs with full
byte-by-byte verification.
Would appreciate your feedback.

value: Show HN: SNKV and LiteFS – Distributed KV store with automatic replication

author: hashmakjsn


value: wulfland

value:
Hey HN,
I built Repstack, an open-source fitness app for evidence-based muscle building. It's inspired by Renaissance Periodization's training methodology.
Key features:
• 100% offline-first PWA - works without internet, installable on any device
• Privacy-first - all data stored locally in IndexedDB, no accounts needed
• Science-based - auto-regulation, mesocycle periodization, volume tracking
• Free forever - core features will never be paywalled
Tech stack: React 19, TypeScript, Vite, Dexie.js, Workbox
I'm a lifter myself and was frustrated that most fitness apps either require subscriptions, don't work offline, or don't follow evidence-based training principles.
Live demo (installable): https://wulfland.github.io/Repstack/
GitHub: https://github.com/wulfland/Repstack
Looking for feedback on UX and contributors interested in fitness tech. The codebase passes WCAG 2.1 AA accessibility and has comprehensive E2E tests.
What features would you want to see?

value: Show HN: Repstack – open-source hypertrophy training app (offline-first PWA)

author: wulfland


value: willmaclean

value:
I spend ~10hrs a day staring at floorplans. I realised that recognising them is quite a skill, so I thought it would be fun to make a game out of it.
There are two modes: multiple choice (surprisingly tricky once you get past the most iconic ones) and an expert mode where you get dropped onto a map and have to locate the building with no options. Expert mode is a bit lol.
Feedback is v much appreciated. The leaderboard is live but a bit janky.
Would also love suggestions for buildings to add, ideally ones where the floor plan is distinctive enough to be guessable but not immediately obvious.

value: Show HN: GeoGuessr, but for Buildings

author: willmaclean

title: Show HN: GeoGuessr, but for Buildings


value: WonderfulSoap

value:
I known there are already plenty of toolbox websites for things like devtools, video, audio, and image processing.
But almost none of them let you create tools tailored to your own workflows — most are fixed, one-size-fits-all utilities.
On top of that, many of these sites require uploading your files to their servers, which raised privacy concerns for me.
So I built ToolBake: a platform where you can create your own tools and run them locally in your browser.
Initially, ToolBake allowed users to define their own UI and handler logic manually. But I quickly realized that asking people to write code and design UIs for every small tool is still too much friction.
One of the original design goals was therefore to combine this customization model with good prompt engineering, so users can describe what they want and let an LLM generate the UI widgets and handler code as a starting point — which they can then inspect, tweak, and extend.
With ToolBake, you can:
- Define your own tool UI and logic directly in the browser
- Run tools locally (no server processing, no data upload)
- Use real capabilities like ffmpeg, ffprobe, ImageMagick, and extend with npm packages
- Optionally use AI assistance to generate UI widgets and handler code
The goal is to combine:
- the flexibility of scripting
- the convenience of a UI
- and the privacy of local execution
ToolBake can be used directly on the hosted site, or self-hosted by running a single Go binary (no runtime dependencies).
All official tools on the demo site are built using the same tool customization mechanism available to users. They are not hardcoded features.
You can inspect these tools to see what the system is capable of, and you can build tools just as powerful by defining your own UI and handlers.
Live demo: https://toolbake.com
GitHub: https://github.com/WonderfulSoap/ToolBake
I’d love feedback on:
- the execution model
- security assumptions
- and what kinds of tools you’d want to build with this

value: Show HN: ToolBake – Build custom tools run in the browser by AI asstent or code

author: WonderfulSoap


value: awneeshtiwari

value: Show HN: I replaced a 200MB JVM process with a 52KB binary that speaks Kafka

author: awneeshtiwari


value: zeybek

value:
I built a VS Code extension for this a while back, and after switching to Neovim, I rebuilt it as a native plugin using extmarks.
It visually masks sensitive values in .env, JSON, YAML, TOML files without modifying the actual content. Useful for screen sharing, recording tutorials, or taking screenshots.
Features:
- Multiple formats (.env, .json, .yaml, .toml, .properties)
- Multiple styles (stars, dots, scramble)
- Custom colors
- Telescope/Snacks picker integration
- Zero file modification
Would love feedback!

value: Show HN: Camouflage.nvim – Hide secrets in config files during screen sharing

author: zeybek


value:
Hi HN,
I'm a software engineer working on C++/python/robotics by day, dabbing into web apps by night. I built The Frontier (https://the-frontier.app) because the LLM market is moving so fast it's hard to tell if you're overpaying for performance.
Pricing is easy to find, but it's hard to tell if you're missing a similarly priced or even cheaper model with better performance. So I built a visualization that maps LM Arena’s Elo scores against OpenRouter’s pricing.
The main thing it does is calculate the Pareto frontier. It highlights the optimal models at each price point, so you can easily spot when a model is technically a "bad deal" compared to its peers.
The hard part:
The real headache wasn't the UI, it was the messy data. LMArena names models one way (e.g. "qwen3-coder-480b-a35b-instruct"), OpenRouter another ("qwen/qwen3-coder"), and you have to deal with a mess of variants like "thinking", "instruct", "fast", or "v1.0" vs "v1". I ended up building an automated scoring system to match these models automatically so the chart stays clean without manual mapping.
I'm pretty happy with the result, I find myself surfing the frontier (literally), going up and down the frontier to find the best model for my use case and budget.
The Tech:
- React + Vite
- ECharts for the visualization
- A daily sync to keep the chart up-to-date with new releases
I also just added Latency and Throughput metrics because sometimes latency or throughput is just as important as intelligence.
I’d love to hear what you think, especially if you spot any weird model matches (Unfortunately they still happen) or have ideas of what to add next ! I have a few ideas, like combining latency and throughput into one, or even intelligence, latency and throughput, I'll call it Wisdom :)
URL: https://the-frontier.app/
Thanks!

value: Show HN: The Frontier, Tracking the LLM Pareto Frontier


value: mzivkovicdev

value: Show HN: Spring CRUD Generator – Maven Plugin to Generate CRUD from YAML

author: mzivkovicdev


value: shreyaspapi

value:
Hi HN, we built and open-sourced a privacy-focused AI chat client.
The goal is simple: the server should not be able to read your chats or access your LLM API keys, even if it’s fully compromised.
Most AI chat tools proxy everything through their backend in plaintext. We wanted something closer to a zero-knowledge design, like a password manager or Signal.
How it works:
- All messages, attachments, history, and API keys are encrypted on-device
- The server only stores encrypted blobs
- Prompts go directly from your browser/device to the model provider (BYOK), not through us
- Native iOS + Android apps
- Passkeys/WebAuthn support
For higher-risk deployments, you can optionally run the backend inside TEEs/enclaves for extra isolation and remote attestation, so even the infrastructure operator can’t inspect memory.
Stack: React, Hono + tRPC, PostgreSQL, Bun.
We built this because we use multiple providers (OpenAI, Anthropic, Ollama, etc.) and didn’t want prompts logged or keys sitting on someone else’s server.
GitHub: https://git.new/onera
Hosted version: https://onera.chat (free during alpha)
iOS: https://apps.apple.com/in/app/onera-private-ai-chat/id675812...
Would love feedback on the design or threat model. Happy to answer questions.

value: Show HN: Onera – end-to-end encrypted AI chat

author: shreyaspapi


value: iafan

value:
I like meditative puzzle games like Minesweeper, and decided to make my interpretation of that game, but with a spherical board where each board tile is determined by a Voronoi algorithm.
To make the game more challenging, beside the number of tiles and density of mines, I added several ways to place seed points on a sphere, where the default Fibonacci method gives the most regular tile shapes, and Random and Chaotic give progressively irregular tiles.
Hope you enjoy this small game as much as I do. Works on iPhone as a PWA, too (couldn't test on Android, though — let me know if there are any issues).

value: Show HN: Minespheres – a Minesweeper-like game with a twist

author: iafan


value: croustibat

value: Show HN: Pennywize-Conversational budgeting for freelancers with variable income

author: croustibat


value: jeffreysmith

value:
I'm Jeff Smith. I've been contributing to AI in open source for a long time, across the Spark, Elixir, and PyTorch ecosystems. I've seen firsthand how open source can be a great place for people to collaborate and build AI together. I even wrote a book about it: https://www.manning.com/books/machine-learning-systems with all open source code: https://github.com/jeffreyksmithjr/reactive-machine-learning...
But the challenges are real. AI-generated code slop and low-quality submissions are flooding projects. Contribution volume is up; signal-to-noise is down. Maintainers can no longer assume a PR represents genuine investment.
Good Egg is a tool I built to help. It mines a contributor's merged PR history across the GitHub ecosystem and computes a trust score relative to your project. The core idea: good contributors are already exhibiting good behavior -- merged PRs in established repos, sustained contributions over time, work across multiple projects. That track record is a strong signal, and it already exists in the GitHub API.
How it works:
- Builds a bipartite contribution graph (users ↔ repositories) from merged PRs
- Applies personalized graph scoring biased toward your project and language ecosystem
- Accounts for recency decay, repository quality (stars, language normalization), and anti-gaming measures (self-contribution penalties, per-repo caps)
- Classifies contributors as HIGH / MEDIUM / LOW / UNKNOWN / BOT
The methodology doc goes into the full detail: https://github.com/2ndSetAI/good-egg/blob/main/docs/methodol...
Runs four ways:
- GitHub Action: drop it into any PR workflow and get a comment with the score
- CLI:  good-egg score <user> --repo <owner/repo>
- Python library: await score_pr_author(login, repo_owner, repo_name, token)
- MCP server: plug it into Claude or other AI assistants
On Vouch and the circle-of-trust approach:
Mitchell Hashimoto's Vouch takes a different angle: maintainers manually vouch for contributors they trust, building a web-of-trust. I think that's a valid approach and have seen circles of trust work well (on PyTorch specifically, where contributors came from all over, including major corporate partners). But I've also seen gaps that could easily be filled by a bit of data that already exists. Vouch requires active maintainer participation in a separate system and has a cold-start problem. Good Egg is complementary. It's automated, doesn't ask maintainers to do extra work, and works from day one on any repo.
What it doesn't do:
Good Egg doesn't send data to any remote service. It reads from the GitHub API, computes locally, and that's it. I'm not building a training set or a contributor database. This is just a tool for the community.
Configuration and extensibility:
Scoring parameters (thresholds, graph weights, recency decay, language multipliers) are all configurable via YAML or environment variables.
More extensibility is planned, particularly around additional data sources (e.g., GitLab) and methodology variations like graph-based project relatedness and incorporating review/issue activity alongside PRs.
Code: https://github.com/2ndSetAI/good-egg
PyPI: pip install good-egg
Docs: https://github.com/2ndSetAI/good-egg/tree/main/docs

value: Show HN: Good Egg: Trust Scoring for GitHub PR Authors

author: jeffreysmith


value: proletarian

value:
CloudVac is a local-only tool to scan, inspect, estimate costs for, and clean up unused AWS resources across multiple profiles and regions.
It reads your `~/.aws/credentials` and discovers resources across services like EC2, RDS, Lambda, S3, CloudFormation stacks, and more. It estimates monthly cost per resource, flags orphaned log groups and under-utilized items, and offers a dependency-aware deletion plan with dry-run safety by default. Everything runs locally with no telemetry and no external calls.
I built this because managing unused AWS resources over many profiles/regions gets expensive and error-prone. Feedback, suggestions, and issues are welcome.
https://github.com/realadeel/CloudVac

value: Show HN: CloudVac – open-source AWS resource cleaner with cost insights

author: proletarian


value: toviszsolt

value: Show HN: QAR - MongoDB-style queries for plain JavaScript arrays.

author: toviszsolt


value: david-minaya

value: Get answers about commands, linux, coding and more. Powered by Ask CLI.

value: Show HN: A powerful search engine to find just what you need

author: david-minaya


value: cranberryturkey

value: Show HN: Non-custodial escrow for crypto – works for AI agents and humans

author: cranberryturkey


value: sebringj

value: Show HN: Autonomo MCP – Developing while E2E Testing

author: sebringj


value: petersonh

value: Built this in ~1 month using Phaser. I'm in-game all day, so if you feel like testing it out with me pop-in!

value: Show HN: I built my first multiplayer web game

author: petersonh


value: renniehaylock

value:
I’m Rennie, founder of Huntr (B2C SaaS, 8 years, 6-person team). I built this to solve a problem that’s been bugging me for years.
There are plenty of MRR forecasting tools: plug in churn, acquisition, ARPU, see where revenue is headed. And there are plenty of cash flow tools: enter expenses, see your burn. But these need to be the same chart. Your runway isn’t a function of expenses alone. It’s how your SaaS metrics interact with your expenses over time.
The thing most tools get wrong: SaaS revenue has lag. When churn creeps up or acquisition slows down, MRR doesn't move in a straight line. The hit (or the bump, when things go well) is steepest in the first few months, then gradually flattens as the compounding plays out. Most founders don't see the shape of it until it’s too late.
The problem is, your brain sees the first two months and draws a straight line. But the curve flattens. So you end up cutting too deep or spending too fast; reacting to a future that was never going to happen.
Airstrip takes your SaaS inputs (new customers/month, churn rate, ARPU), forecasts MRR with the lag modeled correctly, then layers in expenses: payroll with start/end dates, recurring costs, one-time expenses, Stripe fees, owner’s draw, estimated taxes. One chart. Forecast up to 60 months.
What makes it useful for me:
 ∙ Change any input, runway updates in real time
 ∙ Hide/show employees to see exactly what cutting or adding a role does
 ∙ Save scenarios, branch off them, compare
 ∙ Share via URL; all variables encode into the link, no export needed
No backend. Everything is local storage. No login, no account, I can’t see your data.
I use this to run Huntr. Built it because the spreadsheet I’d been maintaining for years finally broke me, and enterprise FP&A tools are $500+/month overkill for a small team.
Totally free to use: https://app.getairstrip.com
Learn more about the product: https://getairstrip.com

value: Show HN: Airstrip – SaaS runway forecasting that models MRR lag

author: renniehaylock


value:
Hi HN, I made TextFix. It fixes selected text (spelling, grammar, clarity) using large language models and pastes it back where you were typing.
I was paying about £8/month for Raycast AI just to do this, so I vibe‑coded my own little version.
I’m dyslexic and this has been really helpful for work, especially for quick fixes and light edits. Curious what people think and what you’d want added.
Repo: https://github.com/johnny1011/textfix
Releases: https://github.com/johnny1011/textfix/releases
Interested to hear what you think.

value: Show HN: TextFix – instant text fixing (spelling/grammar) with LLMs on macOS


value: judeboscogibbs

value:
Hi HN — been working on something new: GrillMyPitch
This is an early MVP built around a problem I hit repeatedly while fundraising: most pitch prep is either static (deck feedback) or human-heavy (coaches), and neither really prepares you for the actual investor conversation.
GrillMyPitch analyzes a pitch deck (PDF) and produces a 0–100 investor-readiness score across 12 parameters, along with concrete rewrite suggestions. After that, it runs a short AI-driven voice conversation that asks the kinds of questions investors tend to push on assumptions, gaps, and unclear narratives, inspired by common VC evaluation frameworks.
I’m posting here mainly to learn. In particular, I’d value thoughts on:
- Whether scoring a pitch is useful or misleading
- How close simulated investor questioning can realistically get
- Where this approach breaks down for different founder profiles
This is very early and likely wrong in places. Happy to answer questions and share how it works.

value: Show HN: GrillMyPitch – An AI investor-readiness simulator for founders

author: judeboscogibbs


value: jelnur

value: Not another habit-building app. I aim it to be a community-driven, curated platform of byte-sized steps to make us better, together.

value: Show HN: Self-improvement platform

author: jelnur

title: Show HN: Self-improvement platform


value: vansxxx

value:
I built OpenClaw Guide, an independent documentation and learning site for OpenClaw users:
https://open-claw.online
What it includes:
- step-by-step setup guides (Windows + VPS)
- channel integration docs (Telegram / WhatsApp / Feishu)
- troubleshooting playbooks
- a skills leaderboard with regular data refresh
The goal is to make onboarding and operations easier, especially for non-native English users (EN + ZH supported now).
I’d really appreciate feedback on:
- what’s unclear or missing in the docs
- which real-world use cases should be covered next
- how to improve navigation/search for faster troubleshooting
Note: this is an independent guide, not the official OpenClaw project.

value: Show HN: OpenClaw Guide – multilingual docs and skills leaderboard

author: vansxxx


value: marchantweb

value: Show HN: Shaders Public Beta – Shader Magic for Modern Frontends

author: marchantweb


value: danbitengo

value: Show HN: SyncKit – Open two browser tabs and watch CRDTs sync in real-time

author: danbitengo


value:
Hi HN,
I’m one of the founders of Vibe.
As founders running a small team, we kept losing time on social media: thinking of ideas, writing posts, adapting them for each platform, scheduling, and then trying to understand what worked.
So we built Vibe for ourselves.
It helps us:
• Turn a single idea into multi-platform posts
• Auto-publish and schedule
• Track engagement in one place
• Run this as a white-label tool for agencies
Stack:
- Spring Boot + AWS
- React
- OpenAI APIs
We’re still early and learning.
Would love honest feedback: what feels useful, what feels unnecessary, and what’s missing.
https://vibe.xpandrai.com

value: Show HN: Vibe – AI tool to automate social media content, posting, and reporting


value: pjf

value:
bgpipe sits between BGP routers as a transparent proxy. It can work as a firewall for the Internet control plane. You build a pipeline of composable stages - connect, listen, grep, exec, rpki, write - and BGP messages flow through them, optionally being filtered, modified, or logged.
A few things you can do:

  # Monitor global BGP for your prefix in real-time (via RIPE RIS Live)
  bgpipe -g -- ris-live -- grep 'prefix ~ 1.1.1.0/24' -- stdout

  # Add RPKI validation between two routers
  bgpipe -- listen 1.2.3.4 -- rpki -- connect 5.6.7.8

  # Pipe through python
  bgpipe -- listen 1.2.3.4 -- exec -LR ./filter.py -- connect 5.6.7.8

  # Convert MRT dump to JSON
  bgpipe -- read updates.mrt.bz2 -- write output.json

The exec stage lets you process BGP in any language - bgpipe sends JSON to your script's stdin and reads JSON back. The grep stage has a small filter DSL (prefix operators, AS_PATH matching, community checks, RPKI tags, etc.).
Single static binary, pure Go, no deps. MIT license.
https://github.com/bgpfix/bgpipe
https://bgpipe.org

value: Show HN: Bgpipe – pipe live BGP sessions through Python, add RPKI, etc.

author: pjf


value: rellfy

value:
Asterbot is a modular AI agent where every capability, such as web search, memory, LLM provider, is a swappable WASM component, sandboxed via WASI.
Components only have access to what you explicitly grant (e.g. a single directory). They're written in any language (Rust, Go, Python, JS) and pulled from the asterai registry.
Under the hood, asterai is a WASM component model registry and runtime built on wasmtime. You publish a component, set an env var to authorize it as a tool, and asterbot discovers and calls it automatically.
I built this because I think the WASM component model is a great way to build software but the ecosystem is missing key infrastructure (especially an open, central registry). AI agents felt like a natural fit since tool security is a real problem, and WASM sandboxing addresses it by default.
Still early stage, but all functionality in the repo is tested and working. Happy to answer questions!

value: Show HN: Asterbot, AI agent where every capability is a sandboxed WASM component

author: rellfy


value: zacharykapank

value:
Most AI job boards are just filters for PyTorch and CUDA. We think that misses the most interesting shift: AI is becoming the new "Excel" or "Typing."
We’re seeing a massive gap where companies need marketers, PMs, and designers who treat LLMs as a standard part of their stack, but these roles get buried under "ML Engineer" listings.
We built a board specifically for roles where AI is a core workflow requirement, not an infrastructure task. If the job requires being 10x more effective via agents and prompting rather than training models, it’s on here.
Is "AI Job" a useful category for non-engineers, or is this just the new definition of "knowledge work"?

value: Show HN: We Love AI Jobs – AI jobs for people who don't write Python

author: zacharykapank


value: cj-cummings

value:
Hey Hacker News!
No one likes to code pricing; it sucks. It shouldn't take up my time, yet it always does - too much of it. And pricing always needs to change, eating up valuable dev hours.
I created a simple pricing engine so that I could write all of my pricing rules & resource limits in a single YAML doc, then enforce them everywhere with a single policy check.
It's simple, intuitive, versionable, auditable, and easy to reason about or change quickly without bogging my development down.
My CTO friends liked the idea and wanted to use it, so I created this open-source library for everyone to try for themselves.
We also have a hosted version that's turnkey for adding Stripe billing & live customer data, so that you can evolve pricing independently from your codebase.
Check it out and let me know what you think! :)

value: Show HN: A simple pricing and resource limit library

author: cj-cummings


value: mhoegh

value: Centia.io now provides a dedicated Model Context Protocol (MCP) server that allows AI agents to interact directly with your Centia.io backend. And a comprehensive Agent Guide.

value: Show HN: Vibe Coding with Centia.io

author: mhoegh

title: Show HN: Vibe Coding with Centia.io


value: Show HN: Epstein Graph – Searchable database of 1.3M+ documents with AI summary


value: Show HN: Xi – No syntax, 10 primitives, dependent types, designed for silicon


value:
I'm building this to help people learn about investing and trading through hands-on practice.
It has virtual trading accounts where you can test strategies, plus a 21-day challenge with daily quizzes and interactive exercises
The goal is to provide a learning path that takes users from foundational concepts to advanced strategies.<p>I would love to hear you're feedback.

value: Show HN: Learn investing and trading fundamentals through interactive simulation


value: Show HN: Impulse AI – I built an MLE agent that placed in top 2.5% on Kaggle


value: KingBor

value: Show HN: ClawKit｜Open-source toolkit to configure and debug OpenClaw AI agents

author: KingBor


value:
Hey HN,
About a year ago I shared a first MVP of a visual node-based system for CI/CD pipelines that I've been very passionate about. I've been building on it since, and it's now live.
I've always liked building pipelines and workflows, but I've never liked writing YAML for anything more than simple linear tasks. Branching, conditions, loops, or trying to just run certain things in parallel always gets messy. So I built Actionforge, a visual node system to tackle some of these pain points.
Instead of writing YAML yourself, you build workflows as graphs. While Actionforge still uses YAML under the hood, the visual editor makes them much easier to maintain. These graphs also run natively on GitHub runners with no middleman. What used to take me hours of fiddling with indentation and string syntax, now only takes me minutes to create a full build pipeline.
The editor comes with a visual debugger so you can run and troubleshoot workflows locally before deploying them.
I dogfood it heavily, so Actionforge builds itself. Here's one of its graphs for GitHub Actions.
https://www.actionforge.dev/example
The runner is written in Go, and is open source on GitHub (including GH Attestation and SBOM for full transparency).
Would love to hear what you think. Happy building!

value: Show HN: I built a visual node system for CI/CD that supports GitHub Actions


value: reb

value:
Hey, I'm Rebekah and I'm building Popmelt, a browser-native toolkit for UI engineering with local LLM CLIs
*tl;dr* Popmelt gives UI engineers and designers a lightweight set of visual feedback and styling/layout tools that talk directly to local LLM CLI instances so you can create and refine your product directly in the browser. This first version is built for React (I've mainly used it with Next.js projects) and plays well with Claude Code and Codex.  It's free to use and I plan to keep it that way.
I started working as a designer and front-end developer on the web in my teens, making myspace layouts for local bands. Since then, I've worked in agencies, ecomm, and startups, bouncing between design and code depending on what each team or client needs.
As LLM code generation has gotten faster and more reliable in the last ~12 months, I've found myself spending more time working with code (directly and indirectly) earlier and earlier in my design process. Last November, design and development have more or less collapsed into a single code-driven step for me, with multiple LLM sessions running in parallel to keep the loop between idea, testing, and iterating as tight as possible.
Along the way I developed a way of working that lets me spend most of my time interacting with the page/product I'm designing without looking at the underlying code. Popmelt bottles that way of working, and saves me from having to flip between the thing I'm designing and the LLM sessions powering it. The repo's README covers most of the details, and I'm happy to answer any questions folks have. Critical feedback is also very welcome.
Thanks for looking!

value: Show HN: A design collaboration layer for local LLM CLIs

author: reb


value: AdelAden

value:
We recently open-sourced Hive after using it internally to support real production workflows tied to contracts totaling over $500k.
Instead of manually wiring workflows or building brittle automations, Hive is designed to let developers define a goal in natural language and generate an initial agent that can execute real tasks.
Today, Hive supports goal-driven agent generation, multi-agent coordination, and production-oriented execution with observability and guardrails.
We are actively building toward a system that can capture failure context, evolve agent logic, and continuously improve workflows over time - that self-improving loop is still under development.
Hive is intended for teams that want:
- Autonomous agents running real business workflows
- Multi-agent coordination
- A foundation that can evolve through execution data
We currently have nearly 100 contributors across engineering, tooling, docs, and integrations. A huge portion of the framework’s capabilities - from CI improvements to agent templates - came directly from community pull requests and issue discussions.
We want to highlight and thank everyone who has contributed. Specifically out top 11 contributors
@vakrahul
@Samir-atra
@VasuBansal7576
@Aarav-shukla07
@Amdev-5
@Hundao
@Antiarin
@AadiSharma49
@Emart29
@srinuk9570
@levxn

value: Show HN: Open sourcing our ERP (Sold $500k contracts, 7k stars)

author: AdelAden


value: Show HN: Verifly – Email verification API at $5/10k (vs $75 for competitors)


value: daviddaadams

value: Show HN: OwlPulse – $9/mo uptime monitoring for indie devs

author: daviddaadams


value: zachdotai

value: Each week we deploy a live AI agent with real tools (web search, browsing, more), a persona, and something it's been told to protect. The system prompt is fully visible. Your job is to break through the guardrails anyway. Fastest successful jailbreak wins and the winning technique gets published for everyone to learn from.<p>First challenge is live now. Give it a shot.

value: Show HN: Fabraix Playground – Weekly Wordle for Breaking AI Agents

author: zachdotai


value: segmenta

value:
Hi HN,
AI agents that can run tools on your machine are powerful for knowledge work, but they’re only as useful as the context they have. Rowboat is an open-source, local-first app that turns your work into a living knowledge graph (stored as plain Markdown with backlinks) and uses it to accomplish tasks on your computer.
For example, you can say "Build me a deck about our next quarter roadmap." Rowboat pulls priorities and commitments from your graph, loads a presentation skill, and exports a PDF.
Our repo is https://github.com/rowboatlabs/rowboat, and there’s a demo video here: https://www.youtube.com/watch?v=5AWoGo-L16I
Rowboat has two parts:
(1) A living context graph: Rowboat connects to sources like Gmail and meeting notes like Granola and Fireflies, extracts decisions, commitments, deadlines, and relationships, and writes them locally as linked and editable Markdown files (Obsidian-style), organized around people, projects, and topics. As new conversations happen (including voice memos), related notes update automatically. If a deadline changes in a standup, it links back to the original commitment and updates it.
(2) A local assistant: On top of that graph, Rowboat includes an agent with local shell access and MCP support, so it can use your existing context to actually do work on your machine. It can act on demand or run scheduled background tasks. Example: “Prep me for my meeting with John and create a short voice brief.” It pulls relevant context from your graph and can generate an audio note via an MCP tool like ElevenLabs.
Why not just search transcripts? Passing gigabytes of email, docs, and calls directly to an AI agent is slow and lossy. And search only answers the questions you think to ask. A system that accumulates context over time can track decisions, commitments, and relationships across conversations, and surface patterns you didn't know to look for.
Rowboat is Apache-2.0 licensed, works with any LLM (including local ones), and stores all data locally as Markdown you can read, edit, or delete at any time.
Our previous startup was acquired by Coinbase, where part of my work involved graph neural networks. We're excited to be working with graph-based systems again. Work memory feels like the missing layer for agents.
We’d love to hear your thoughts and welcome contributions!

value: Show HN: Rowboat – AI coworker that turns your work into a knowledge graph (OSS)

author: segmenta


value: stedwick

value: I wasn't able to find any other app that successfully combined TradFi and DeFi into a single page. So I built this for myself, and I hope you folks can find it useful as well!<p>My app supports anything in the Yahoo Finance API or in a Bitcoin, Ethereum & EVM, or Solana wallet. Can you think of anything else it should track?

value: Show HN: I just want *one page* to see all investments, so that's what I built

author: stedwick


value: djrhails

value: Show HN: Browse neologisms for the feelings and experiences English can't name

author: djrhails


value: catdeleon

value:
Hi HN
I’m a product designer, not an engineer, and I built a daily word puzzle you can play directly in your browser.
There are lots of Spelling Bee-style games out there and most of them are great for solo play.bee with me is different by design. It's built for collaboration:
- everyone plays on their own device
- everyone can enter their words themselves
- everyone can shuffle the board independently
while all the progress towards Genius is shared.
I built this as a side project because I love word games and wanted something I could play quickly without friction — and I wanted to see how far I could get using Lovable as a non-engineer.
Lovable handled most of the app logic and wiring, and I focused on game design, UX, and tuning the word list so it felt challenging without being frustrating.
I’d really appreciate feedback — especially around difficulty balance, UX, or anything that feels confusing or unfair.
Game link: https://wannabeewith.me
Thanks for checking it out—and happy to answer any questions about the build, design decisions, or launch process.
— Cat

value: Show HN: A real-time collaborative word puzzle inspired by NYT Spelling Bee

author: catdeleon


value: yethiel

value: Show HN: I made paperboat.website, a platform for friends and creativity

author: yethiel


value:
Hello HN,
We built ClearDemand to solve the "hallucination" problem in legal drafting. General LLMs are great at writing, but terrible at accuracy—which is a dealbreaker when citing medical evidence in a demand letter.
The Problem: Personal Injury firms spend hundreds of hours manually summarizing unstructured medical records (PDFs) to draft demand letters. If they miss a specific injury or treatment date, the settlement value drops.
The Solution: ClearDemand is a drafting platform that ingests raw case files (police reports, medical records, invoices), runs OCR, and uses RAG to generate drafts that are source-verified.
Grounded Generation: Every claim in the generated letter includes a citation linking back to the specific page in the source document.
Cross-Case Search: We index the firm’s entire history, allowing lawyers to search across past matters to find similar fact patterns or successful arguments.
Style Matching: It learns the firm’s specific tone/structure so the output doesn't sound like generic AI.
We’re offering a 14-day trial to see if the OCR pipeline holds up against your messiest scanned PDFs.
Feedback on our citation UI would be much appreciated!
Thanks.

value: Show HN: ClearDemand – Cross-case search and drafting for injury firms


value: guivr

value: Show HN: I made an OSS dashboard to track your Stripe, RevenueCat, Gumroad data

author: guivr


value: georgeck

value:
HN is all about the rich discussions. We wanted to take the HN experience one step further - to bring the familiar keyboard-first navigation, find interesting viewpoints in the threads and get a gist of long threads so that we can decide which rabbit holes to explore. So we built HN Companion a year ago, and have been refining it ever since.
Try it: https://app.hncompanion.com or available as an extension for Firefox / Chrome: [0].
Most AI summarization strips the voices from conversations by flattening threads into a wall of text. This kills the joy of reading HN discussions. Instead, HN Companion works differently - it understands the thread hierarchy, the voting patterns and contrasting viewpoints - everything that makes HN interesting. Think of it like clustering related discussions across multiple hierarchies into a group and surfacing the comments that represent each cluster. It keeps the verbatim text with backlinks so that you never lose context and can continue the conversation from that point. Here is how the summarization works under the hood [1].
We first built this as an open source browser extension. But soon we learned that people hesitate to install it. So we built the same experience as a web app with all the features. This helped people see how it works, and use it on mobile too (in the browser or as PWA). This is now a playground to try new features before taking them to the browser extension.
We did a Show HN a year ago [2] and we have added these features based on user feedback:
* cached summaries - summaries are generated and cached on our servers. This improved the speed significantly. You still have the      option to use your own API key or use local models through Ollama.
* our system prompt is available in the Settings page of the extension. You can customize it as you wish.
* sort the posts in the feed pages (/home, /show etc.) based on points, comments, time or the default sorting order.
* We tried fine tuning an open weights model to summarize, but learned that with a good system prompt and user prompt, the frontier models deliver results of similar quality. So we didn’t use the fine-tuned model, but you can run them locally.
The browser extension does not track any usage or analytics. The code is open source[3].
We want to continue to improve HN Companion, specifically add features like following an author, notes about an author, draft posts etc.
See it in action for a post here https://app.hncompanion.com/item?id=46937696
We would love to get your feedback on what would make this more useful for your HN reading.
[0] https://hncompanion.com/#download
[1] https://hncompanion.com/how-it-works
[2] https://news.ycombinator.com/item?id=42532374
[3] https://github.com/hncompanion/browser-extension

value: Show HN: HN Companion – web app that enhances the experience of reading HN

author: georgeck


value: DSpider

value: Show HN: Deploy Multiple OpenClaw Assistants Easily

author: DSpider


value:
GitHub: https://github.com/ClioAI/kw-sdk
Most AI agent frameworks target code. Write code, run tests, fix errors, repeat. That works because code has a natural verification signal. It works or it doesn't.
This SDK treats knowledge work like an engineering problem:
Task → Brief → Rubric (hidden from executor) → Work → Verify → Fail? → Retry → Pass → Submit
The orchestrator coordinates subagents, web search, code execution, and file I/O. then checks its own work against criteria it can't game (the rubric is generated in a separate call and the executor never sees it directly).
We originally built this as a harness for RL training on knowledge tasks. The rubric is the reward function. If you're training models on knowledge work, the brief→rubric→execute→verify loop gives you a structured reward signal for tasks that normally don't have one.
What makes Knowledge work different from code? (apart from feedback loop)
I believe there is some functionality missing from today's agents when it comes to knowledge work. I tried to include that in this release. Example:
Explore mode: Mapping the solution space, identifying the set level gaps, and giving options.
Most agents optimize for a single answer, and end up with a median one. For strategy, design, creative problems, you want to see the options, what are the tradeoffs, and what can you do? Explore mode generates N distinct approaches, each with explicit assumptions and counterfactuals ("this works if X, breaks if Y"). The output ends with set-level gaps ie what angles the entire set missed. The gaps are often more valuable than the takes. I think this is what many of us do on a daily basis, but no agent directly captures it today. See https://github.com/ClioAI/kw-sdk/blob/main/examples/explore_... and the output for a sense of how this is different.
Checkpointing: With many ai agents and especially multi agent systems, i can see where it went wrong, but cant run inference from same stage. (or you may want multiple explorations once an agent has done some tasks like search and is now looking at ideas). I used this for rollouts a lot, and think its a great feature to run again, or fork from a specific checkpoint.
A note on Verification loop:
The verify step is where the real leverage is. A model that can accurately assess its own work against a rubric is more valuable than one that generates slightly better first drafts. The rubric makes quality legible — to the agent, to the human, and potentially to a training signal.
Some things i like about this:
- You can pass a remote execution environment (including your browser as a sandbox) and it would work. It can be docker, e2b, your local env, anything, the model will execute commands in your context, and will iterate based on feedback loop. Code execution is a protocol here.
- Tool calling: I realize you don't need complex functions. Models are good at writing terminal code, and can iterate based on feedback, so you can just pass either functions in context and model will execute or you can pass docs and model will write the code. (same as anthropic's programmatic tool calling). Details: https://github.com/ClioAI/kw-sdk/blob/main/TOOL_CALLING_GUID...
Lastly, some guides:
- SDK guide: https://github.com/ClioAI/kw-sdk/blob/main/SDK_GUIDE.md
- Extensible. See bizarro example where i add a new mode: https://github.com/ClioAI/kw-sdk/blob/main/examples/custom_m...
- working with files: https://github.com/ClioAI/kw-sdk/blob/main/examples/with_fil...
- this is simple but i love the csv example: https://github.com/ClioAI/kw-sdk/blob/main/examples/csv_rese...
- remote execution: https://github.com/ClioAI/kw-sdk/blob/main/examples/with_cus...
And a lot more. This was completely refactored by opus and given the rework, probably would have taken a lot of time to release it.
MIT licensed. Would love your feedback.

value: Show HN: Open-Source SDK for AI Knowledge Work


value: prashantsengar

value:
I built GitEcho after the recent GitHub outages led me to reading this HN comment: https://news.ycombinator.com/item?id=46947085.
My goal was simple: make GitHub mirroring dead simple and invisible.
Set it up once, then forget it.
I wanted "push to GitHub" to also mirror to another provider (GitLab/Bitbucket/Gitea/self-hosted) without changing my day-to-day workflow.
How it works:
- ge add <mirror-url> installs a local pre-push hook
- normal git push origin ... still works as usual
- GitEcho captures pushed refs and mirrors them in the background
- it uses existing SSH keys / git credential helper (no new token system)
Install:
uv tool install gitecho
Quick start:
ge add git@gitlab.com:you/repo.git
git push origin main
Why not just add another remote and push yourself?
You can, and that works. I am lazy and forgetful. I wanted something I could set up quickly and never think about again.
GitEcho packages the boring parts: hook setup, background push, non-interactive auth behavior, and logs (`ge logs`).
Current behavior:
- safety-first by default: it checks origin refs before mirror push
- if origin likely rejected, mirror push is skipped and logged
- optional best-effort mode via `GITECHO_CONTINUE_ON_ORIGIN_REJECT=1`
Planned next:
- auto-create mirror repos on providers
- watch a folder and auto-setup all repos (instead of per-repo setup)
Repo: https://github.com/prashantsengar/GitEcho
Mirrored at: https://gitlab.com/prashantsengar/gitecho

value: Show HN: GitEcho – set-and-forget Git mirroring on every push

author: prashantsengar


value: prasoonds

value:
Hey HN, stripe-no-webhooks is an open-source library that syncs your Stripe payments data to your own Postgres database:
https://github.com/pretzelai/stripe-no-webhooks.
Here's a demo video: https://youtu.be/cyEgW7wElcs
Why is this useful? (1) You don't have to figure out which webhooks you need or write listeners for each one. The library handles all of that. This follows the approach of libraries like dj-stripe in the Django world (https://dj-stripe.dev/). (2) Stripe's API has a 100 rpm rate limit. If you're checking subscription status frequently or building internal tools, you'll hit it. Querying your own Postgres doesn't have this problem. (3) You can give an AI agent read access to the stripe.* schema to debug payment issues—failed charges, refunds, whatever—without handing over Stripe dashboard access. (4) You can join Stripe data with your own tables for custom analytics, LTV calculations, etc.
It creates a webhook endpoint in your Stripe account to forward webhooks to your backend where a webhook listener stores all the data into a new stripe.* schema. You define your plans in TypeScript, run a sync command, and the library takes care of creating Stripe products and prices, handling webhooks, and keeping your database in sync. We also let you backfill your Stripe data for existing accounts.
It supports pre-paid usage credits, account wallets and usage-based billing. It also lets you generate a pricing table component that you can customize. You can access the user information using the simple API the library provides:

  billing.subscriptions.get({ userId });
  billing.credits.consume({ userId, key: "api_calls", amount: 1 });
  billing.usage.record({ userId, key: "ai_model_tokens_input", amount: 4726 });

Effectively, you don't have to deal with either the Stripe dashboard or the Stripe API/SDK any more if you don't want to. The library gives you a nice abstraction on top of Stripe that should cover ~most subscription payment use-cases.
Let's see how it works with a quick example. Say you have a billing plan like Cursor (the IDE) used to have: $20/mo, you get 500 API completions + 2000 tab completions, you can buy additional API credits, and any additional usage is billed as overage.
You define your plan in TypeScript:

  {
    name: "Pro",
    description: "Cursor Pro plan",
    price: [{ amount: 2000, currency: "usd", interval: "month" }],
    features: {
      api_completion: {
        pricePerCredit: 1,              // 1 cent per unit
        trackUsage: true,               // Enable usage billing
        credits: { allocation: 500 },
        displayName: "API Completions",
      },
      tab_completion: {
        credits: { allocation: 2000 },
        displayName: "Tab Completions",
      },
    },
  }

Then on the CLI, you run the `init` command which creates the DB tables + some API handlers. Run `sync` to sync the plans to your Stripe account and create a webhook endpoint. When a subscription is created, the library automatically grants the 500 API completion credits and 2000 tab completion credits to the user. Renewals and up/downgrades are handled sanely.
Consume code would look like this:

  await billing.credits.consume({
    userId: user.id,
    key: "api_completion",
    amount: 1,
  });

And if they want to allow manual top-ups by the user:

  await billing.credits.topUp({
    userId: user.id,
    key: "api_completion",
    amount: 500,     // buy 500 credits, charges $5.00
  });

Similarly, we have APIs for wallets and usage.
This would be a lot of work to implement by yourself on top of Stripe. You need to keep track of all of these entitlements in your own DB and deal with renewals, expiry, ad-hoc grants, etc. It's definitely doable, especially with AI coding, but you'll probably end up building something fragile and hard to maintain.
This is just a high-level overview of what the library is capable of. It also supports seat-level credits, monetary wallets (with micro-cent precision), auto top-ups, robust failure recovery, tax collection, invoices, and an out-of-the-box pricing table.
I vibe-coded a little toy app for testing: https://snw-test.vercel.app. There's no validation so feel free to sign up with a dummy email, then subscribe to a plan with a test card: 4242 4242 4242 4242, any future expiry, any 3-digit CVV.
Screenshot: https://imgur.com/a/demo-screenshot-Rh6Ucqx
Feel free to try it out! If you end up using this library, please report any bugs on the repo. If you're having trouble / want to chat, I'm happy to help - my contact is in my HN profile.

value: Show HN: Stripe-no-webhooks – Sync your Stripe data to your Postgres DB

author: prasoonds


value: aytuakarlar

value:
Hi HN, I'm Aytug, the creator of CSL-Core.
We built this because we realized that "prompt engineering" isn't enough for critical AI systems (like in finance or governance). You can't just ask an LLM nicely not to delete a database—you need a runtime guarantee.
CSL-Core is a policy language designed to bring "Policy-as-Code" to AI agents.
Instead of relying on the model's probabilistic nature, CSL enforces constraints that are:
1. Formally Verified: Policies are compiled into Z3 constraints to mathematically prove they have no logical conflicts or loopholes.
2. Deterministic: The checks happen in a separate runtime engine, independent of the LLM's context window.
3. Model Agnostic: It acts as a firewall between the LLM and your tools/API.
It's currently in Alpha (v0.2). Currently working on TLA+ specifications for the dual formal verification engine and governance architecture because we believe AI safety needs mathematical rigor.
I'd appreciate any feedback on the DSL syntax and our verification approach.

value: Show HN: CSL-Core – Formally Verified Neuro-Symbolic Safety Engine for AI

author: aytuakarlar


value: karakhanyans

value: Show HN: RoadmapAI – Turn Discord chatter into a product roadmap with AI

author: karakhanyans


value: Xarovin

value:
The first version of MouseTracks I made all the way back in 2017. It got a lot of interest, but I never had the skill to actually complete it. I finally made a start on 2.0 a bit over a year ago, and I've been chipping away at it for fun ever since.
Some key features:
- Track mouse movements, clicks, keyboard, and controller inputs (you can optionally disable any of these).
- Switch profiles depending on what game / application is loaded.
- Live render preview in the GUI.
 -It's designed to flawlessly handle multiple monitors and different resolutions.
- Older mouse movements gradually fade to keep focus on the most recent activity.
- Data can be recorded for years and rendered at any time.
It's designed as a "run and forget" type application, where you tick an option to load in the background on startup, and it'll silently keep recording until you're ready to render (it doesn't do that by default though - it just acts as a normal portable application if you don't change any settings).
It's all open source and compatible with Windows/Linux/macOS. The executables are built automatically by GitHub Actions, and there's also instructions on how to build or run locally with Python.
Feel free to ask any questions. I've got a bunch of example renders on the GitHub page which should hopefully demonstrate it properly.

value: Show HN: Track your input data and create colourful renders with it

author: Xarovin


value: pattle

value: Show HN: Race across the world using only public transport

author: pattle


value: bigmotion

value: As a data analysis student, working with csv and excel sheets is important, in the phase cleaning you face several problems that can break the process, so I've built a free tools website + chrome extension to solve this problem, give it a try

value: Show HN: Fix your CSV's files problems

author: bigmotion

title: Show HN: Fix your CSV's files problems


value: chrisnagel

value:
I've been working in GIS/mapping for a few years and found myself increasingly adjacent to machine learning and computer vision, which got me thinking about what I've been calling "broad spectrum" computer vision, object and anomaly identification beyond the visible range of light.
This is my first pass at building a tool to understand the physics involved, from electromagnetic absorption and reflectance of sunlight through to corrected sensor observation. I've been focused on building out and validating existing spectral indices to understand the fundamentals before exploring my own based on molecular properties of materials from first principles.
So far the tool includes:
-An atmospheric correction processor with three methods: empirical band-ratio, Py6S radiative transfer, and ISOFIT optimal estimation
-An interactive viewer for both radiance and reflectance data with RGB composites, 23 spectral indices, and ROI-based spectral signature extraction with reference material matching
-A learning suite that explains each stage of the observation chain from solar irradiance to sensor capture
So far I've tested on AVIRIS-3 data from Santa Barbara Island, San Joaquin Valley and Cuprite, NV.
I'd love a sanity check on the direction and general utility. If anyone works with hyperspectral data and wants to take a crack at stress testing, install requires Python 3.9+ and optionally conda for Py6S.

value: Show HN: Hyperspectra – Desktop tool for exploring AVIRIS-3 hyperspectral images

author: chrisnagel


value:
I've done this same println debugging thing so many times, along with some sed/awk stuff to figure out which call was causing the issue. Now it's a small Go package.
With some `runtime.Callers` I can usually find the spot by just swapping the existing Mutex or RWMutex for this one.
Sometimes I switch the

  mu.Lock()
  defer mu.Unlock()

with the LockFunc/RLockFunc to get more detail

  defer mu.LockFunc()()

I almost always initialize it with `deadlog.New(deadlog.WithTrace(1))` and that's plenty.
Not the most polished library, but it's not supposed to land in any commit, just a temporary debugging aid. I find it useful.

value: Show HN: Deadlog – almost drop-in mutex for debugging Go deadlocks


value: Show HN: Standalone SEO library for PHP, v3 released


value: xpekeler

value:
I've ported the BaaS PocketBase, which is implemented in Go, to TypeScript specifically for the Bun runtime.
PocketBase is awesome and already allows for extensions in JavaScript, but is limited due to the embedded JSVM goja which isn't fully ES6 compatible and makes using npm packages tricky.
PocketBun solves this issue.
The development process was also interesting: porting almost 100K lines of code with Codex over the course of just a few days. The process is written up in this gist: https://gist.github.com/pekeler/49eb987b832047c3d781d00d0460...

value: Show HN: PocketBun (PocketBase Ported to Bun)

author: xpekeler


value: simonw

value: Show HN: Showboat and Rodney, so agents can demo what they've built

author: simonw


value: knes

value: Show HN: We got sick of juggling terminals for AI agents so we built a workspace

author: knes


value:
Hi everyone!
I wanted to create something simple yet addictive. I just launched glow dash chase hyper- casual web game where you dodge obstacles and collect gems in a neon-
I'd love to get your feedback
on the gameplay mechanics and the difficulty curve.
Let me know your high score!

value: Show HN: I Made a New Game

title: Show HN: I Made a New Game


value: nicolasbistolfi

value: A Go library for detecting and removing personally identifiable information (PII) from text and structured data.

value: Show HN: Deidentify data before LLM with Go

author: nicolasbistolfi


value: Show HN: Creature – Desktop Client for Building and Sharing MCP Apps Within Orgs


value: NeuralAA

value:
Excited to share what ive been working on..
I Built my first product and finally shipping it after a ton of work on it..
I am introducing Prism Canvas.. upload a PDF, get a visual map of every concept inside it. Each concept comes with its own breakdown: summaries, key stats, timelines, comparison tables, and live interactive simulations you can actually play with (sliders, toggles, and more.. the whole thing). You can also chat with your document and pull up the source at any point.
My first real product launch would appreciate anyone giving it a look, and all feedback is appreciated
Get your first month for free using code “LAUNCH” at checkout
You can also just Ask Prism Anything: type a question, get a map of the topic, explore each concept, and check sources as you go.
You can also take notes, draw, and sketch ideas directly in Prism, powered by @excalidraw
Check it out now and get your first month for FREE using code LAUNCH at checkout
https://prismcanvas.app/welcome
If anyone has any questions on the stack or implementation or any feedback feel free to ask as well

value: Show HN: Prism Canvas, upload a PDF, get a visual map of every concept

author: NeuralAA


value: jzapletal

value:
Desktop app that:
- Takes screenshots of your activity
- Summarizes with vision models, then deletes the screenshot
- Stores text summaries locally
- Exposes it to AI tools via MCP
Demo: https://www.loom.com/share/513b213e82d14323999e419fa434576d
Feedback welcome, especially around privacy/security and technical approach

value: Show HN: I hate re-explaining the same context to Claude/Cursor

author: jzapletal


value: acossta

value:
Hi HN,
I’m Nico, one of the co-founders of BrainGrid.
We built this after spending the last year building software almost entirely with AI coding tools like Claude Code and Cursor. Writing code was fast. Finishing anything reliably was not.
Coding was not the bottleneck. planning was. It was everything before the code: unclear scope, missing edge cases, poor sequencing, and vague intent. Once a project went beyond a single prompt, small changes started breaking unrelated parts of the app.
In traditional teams, product managers and tech leads handle this. I was a Director of Product at Twilio for over a decade. In AI-native development, that role is missing, especially for solo builders and non-technical founders.
BrainGrid is an attempt to fill that gap.
It’s a product planning agent that helps you think through what to build before asking an AI to write code. You describe a feature or product idea, and BrainGrid:
- asks clarifying questions
- maps basic user flows and specs UIs
- writes structured requirements
- produces clean, scoped inputs you can hand to AI coding tools
The output is not code. It’s a plan that AI tools can actually execute without drifting.
The product is live today. You can try it in the browser, or hand tasks to Claude Code or Cursor via copy-paste, CLI or MCP. There’s a free tier, and you can explore it without committing to anything heavy.
https://www.braingrid.ai

value: Show HN: BrainGrid – The AI Product Planner: Structure Your Ideas for AI

author: acossta


value: jackculpan

value: Show HN: FlightClaw – OpenClaw skill that tracks Google Flights for price drops

author: jackculpan


value: wolfer

value:
Hey all!
Following up on a previous post (had a bit of a hug of death) - https://news.ycombinator.com/item?id=46255827
Have made a lot of improvements to make it actually useful and move to a stable domain (desktop still best, but it at least works now on mobile):
Butcher list - Lots more butchers added to the scraper.
Browse by Cut - This is the big one. Instead of scrolling through 1000+ individual products, you can now browse by standardised cut (Ribeye, Brisket, Lamb Leg, etc). I've mapped products from a selection of popular butchers to ~154 canonical cuts. Click a cut and see every matching product across all sites, sorted by price/kg. Looking to improve taxonomy over time with ongoing missed matches/remaps where the automation was wrong.
90-day price ratings - I've been collecting price data for a while now, so the site can tell you if a product is at its lowest price in 90 days () or within 5% of that low (). Handy for spotting whether a "sale" is actually a good deal.
Fresh vs Frozen indicators - Shows up on both the cut list and product detail pages. Filter by storage type if you only want one or the other.
Table layout - Ditched the card grid for a proper table. Much easier to scan prices when everything's lined up in columns. Sortable by name, protein, type, price, number of options, or number of sites stocking it.
Full row click - Click anywhere on the row, not just the tiny product name link. Small thing but it was annoying me.
Looking for as much feedback as I can get, please share!

value: Show HN: Update UK Butchers Meat Price Tracker

author: wolfer


value: samgutentag

value:
Hey HN! I built this map for Santa Barbara Burger Week, a local event where ~40 restaurants each offer a $10 burger.
The local paper publishes a list of participating restaurants but not a map, so I built one!
The entire app was built using Claude Code in one session. The stack is intentionally minimal: a single index.html, vanilla JS, Leaflet with MarkerCluster, and restaurant data in a plain JS file hosted on GitHub Pages.
Wrote up a blog post about my (very simple) Claude Code workflow and what worked/didn't: https://www.gutentag.world/blog/2026-02-10-let-claude-cook-b...
Source: https://github.com/samgutentag/sbburgerweek

value: Show HN: I built a Burger Week map for my city using Claude Code in an hour

author: samgutentag


value:
RAGtime is a self-hosted MCP server and FAISS/PGVector manager that lets AI assistants run real operations on your infrastructure: SSH commands, SQL queries through SSH tunnels, git repo indexing, filesystem searches. It connects Claude, OpenAI, or Ollama to your environment via both MCP protocol and OpenAI-compatible chat completions API.
I originally built this over Christmas break as a "self-serve business intelligence" tool to stop fielding repetitive coworker questions ("write me a query for X," "where's the logic for Y?") but now it's morphed into a dev tool as well. I couldn't find anything that centralized these tools and served them over chat in one place.
I've been using it daily (via MCP) for work and it's been such a huge development accelerator for me. I want to share what I've built with the community, get feedback, or if you wish, contributions. Happy to answer questions about the architecture or use cases.
(You can stop here, unless you want more technical details...)
Tools: The agent gets access to configurable tools you define: SSH connections to servers (run commands, check logs, restart services), database queries via SSH tunnels (PostgreSQL, MySQL, MSSQL) with parameterized queries to prevent injection, and vector search over your indexed content. Each tool is defined in a config with connection details, and you can enable/disable them per use case. The database tools return structured results the LLM can reason about. SSH tools stream output for long-running commands. There's also a Python REPL tool for data manipulation when the LLM needs to transform query results.
On the RAG/indexing side: Chunking uses Chonkie's CodeChunker with Magika (Google's ML model) for automatic language detection, then tree-sitter for AST-aware splitting that respects semantic boundaries (functions, classes, blocks). Each code chunk gets a header with file path and import context so the LLM knows where it came from. Retrieval uses MMR (Maximal Marginal Relevance) to reduce near-duplicate results, balancing relevance with diversity via a configurable lambda parameter. FAISS indexes are portable and can be exported.

value: Show HN: Self-hosted MCP server for SQL, SSH, and FAISS indexing


value: songqipu

value: Show HN: roro - Most Fun & Whimsical Agent Observability IDE

author: songqipu


value: adammfrank

value:
I built an app that turns any online recipe into a printable 3x5 index card.
If you cook from the internet, you know the pain: scrolling past a 2,000-word story about someone's grandmother just to find the ingredient list. Then trying to read it off your phone with wet hands.
So I built Tasty A.F. — paste a recipe URL, and it uses AI to extract the essentials and format them onto a clean, printable notecard.
How it works:
1. Paste any recipe URL
2. AI scrapes the recipe and generates a concise 3x5 card
3. Print it, stick it on the fridge or a notecard, and cook
Built with Python/Flask and the Anthropic Claude API, hosted on Railway.

value: Show HN: Tasty A.F. – Turn Any Online Recipe into a 3x5 Notecard

author: adammfrank


value: I'm so tired of vendors showing up with a SOC 2 thinking that closes the deal. Great, you passed an audit — but you don't support SSO, I can't get logs out of your platform, and your engineers have access to all my data. I don't care about your SOC 2. Yes, you need it to prove to me you aren't some vibe-coded app running on the side (some of these actually do have SOC 2s too), but what I care about beyond that is that I can secure your tool according to my stack and my requirements. Use Traction to show me what product security you've implemented. Please.

value: Show HN: Traction – Security readiness framework for scaling SaaS teams


value:
I work on real-time voice/video AI at Tavus and for the past few years, I’ve mostly focused on how machines respond in a conversation.
One thing that’s always bothered me is that almost all conversational systems still reduce everything to transcripts, and throw away a ton of signals that need to be used downstream. Some existing emotion understanding models try to analyze and classify into small sets of arbitrary boxes, but they either aren’t fast / rich enough to do this with conviction in real-time.
So I built a multimodal perception system which gives us a way to encode visual and audio conversational signals and have them translated into natural language by aligning a small LLM on these signals, such that the agent can "see" and "hear" you, and that you can interface with it via an OpenAI compatible tool schema in a live conversation.
It outputs short natural language descriptions of what’s going on in the interaction - things like uncertainty building, sarcasm, disengagement, or even shift in attention of a single turn in a convo.
Some quick specs:
- Runs in real-time per conversation
- Processing at ~15fps video + overlapping audio alongside the conversation
- Handles nuanced emotions, whispers vs shouts
- Trained on synthetic + internal convo data
Happy to answer questions or go deeper on architecture/tradeoffs
More details here: https://www.tavus.io/post/raven-1-bringing-emotional-intelli...

value: Show HN: Multimodal perception system for real-time conversation


value: tonyspiro

value:
Hi HN, I'm Tony, founder of Cosmic (a headless CMS). We just open-sourced a CLI that covers the full lifecycle of a content-driven app from creating the content model to deploying to production to updating the codebase all without leaving the terminal.
Here's what the full workflow looks like:

  # Create a project with an AI-generated content model
  cosmic projects create
  # → "A recipe blog with recipes, categories, and authors"

  # Generate content
  cosmic content -p "Create 5 recipes with images across different categories"

  # Build a full-stack app wired to your content
  cosmic build -p "A modern recipe blog with search and category filtering"
  # → Generates a Next.js app, pushes to GitHub

  # Deploy
  cosmic deploy start --watch
  # → Deployed to Vercel

  # Later: update the existing codebase with natural language
  cosmic update recipe-blog -p "Add dark mode and a favorites feature" -b feature-branch

  # Create a PR and merge
  cosmic repos pr create <repoId>
  cosmic repos pr merge <repoId> 1
  # → Auto-deploys to production

That's the part I think is interesting: it's not just one step, it's the full loop. Create content, build the app, ship it, iterate on it, merge and redeploy. Each step is a single command.
A few of the more technically interesting pieces:
AI agents. You can create three types: content agents (CMS operations), repository agents (code changes on branches), and computer use agents (browser automation via Puppeteer with AI vision). Chain them into multi-step workflows with scheduling.
Interactive shell. "cosmic shell" drops into a REPL where you navigate workspaces and projects like a filesystem: cd, ls, pwd. System commands with ! prefix. No cosmic prefix needed.
Multi-model. Supports Claude Opus/Sonnet/Haiku, GPT-5/5.2/5-mini/4o, and Gemini 3 Pro. Set a default or specify per-command.
It also handles the day-to-day stuff you'd normally do in a dashboard: billing, team roles, webhooks, domain/DNS config, environment variables.
Built with TypeScript and Commander.js. MIT licensed.
Install: npm install -g @cosmicjs/cli
GitHub: https://github.com/cosmicjs/cli
Docs: https://www.cosmicjs.com/docs/cli
Happy to answer questions.

value: Show HN: Cosmic CLI – Build, deploy, and manage apps from your terminal with AI

author: tonyspiro


value:
Hi HN — I built this after repeatedly seeing LLM cost regressions slip through review because nothing breaks; it’s just token drift and then a surprise bill.
AIOpt is a local-only CLI + CI gate that:
- uses observed usage as a baseline (usage.jsonl/csv)
- estimates candidate deltas (model/context/output/retry/traffic)
- emits deterministic artifacts + SARIF for GitHub Code Scanning
No server, no uploads.
I’d really appreciate feedback on what would make this more useful in real PR review:
1) What signals/UX make token/cost regressions actionable (beyond “it’s higher”)?
2) Any must-have integrations you’d expect?

value: Show HN: AIOpt – local-only guardrail for LLM token/cost regressions


value:
My friend wanted to give everyone on my team their own OpenClaw agent but quickly ran into the obvious problems: no isolation, no auth, no way to manage N instances without it becoming a mess.
Claworc is a lightweight control plane that wraps each OpenClaw instance in its own container. You get a web UI to create/stop/remove instances, watch the agent's browser live via proxied noVNC, chat with agents, manage files, and stream logs. All traffic goes through a single entry point with authentication.
Access control is multi-user with admin and user roles — admins manage everything, users only see instances assigned to them. You set global API key defaults so you're not copy-pasting keys into every instance, but each instance can override with its own model and keys. Works with any LLM that OpenClaw supports.
Deploys on Docker for a single box or Kubernetes for production. The control plane is a single Go binary serving the dashboard and proxy.
Instances are fully isolated (separate filesystems, no inter-instance communication), monitored by systemd, and auto-restarted on crash. Storage persists across restarts.
Open source, self-hosted, MIT licensed. Feedback and contributions welcome.

value: Show HN: Claworc – Manage multiple OpenClaw instances from a single dashboard


value:
If you're a non-technical founder, you probably have no idea what your developers did last week. You ask, they say "refactored the auth module" and you nod pretending you understand.
Gitmore reads your GitHub activity and turns it into a simple report: what was built, what was fixed, what's stuck. Written for humans, not engineers.
It shows up in your inbox. You read it in 2 minutes. Done.
Here's what a report looks like: https://www.gitmore.io/example.html
Quick demo: https://demo.arcade.software/5tZyFDhp1myCosw6e1po
Free tier available. Happy to hear what you'd want from something like this.

value: Show HN: Ask your AI what your devs shipped this week


value: goldminator

value:
I built a small tool that emails you when a webpage changes.
It tracks the text content and sends a diff when something changes.
Pages are checked every 30 minutes.
https://pagechange.carrd.co
Happy to hear feedback.

value: Show HN: Get notified when a webpage changes

author: goldminator


value:
Built an expense tracking agent that takes a photo of a receipt and extracts merchant, line items, totals, and date, then categorizes based on your past spending habits. It also flags prices as good, bad, or fair.
Stack is Next.js 15, Supabase, Reducto for document parsing, and Subconscious for agent orchestration. The actual integration between the two is around 100 lines of code.
Wanted to see what a practical AI agent looks like as a real product rather than a chatbot wrapper. Open to feedback on the agent architecture especially.

value: Show HN: OS Receipt reader with Subconscious agents and Reducto document parsing