value: agentic-wiki

value:
What started as a viral "Mac Mini" enthusiast project ended with a Valentine's Day "hard launch" of its founder joining OpenAI.
But the real story isn't the hiring—it's the supply chain decay.
I’ve audited the technical strata of the transition, specifically focusing on:
CVE-2026-25253 (The 1-Click RCE): How missing WebSocket origin validation allowed any website to hijack a local agent and exfiltrate host credentials.
The "ClawdHub" Poisoning: How an unvetted "skills" marketplace became a delivery mechanism for AMOS infostealers while the community was distracted by name changes.
Vibe-Coding vs. Engineering: Why building agents with "root-by-default" and no permission boundaries made this project a lethal liability for the 60k+ developers who starred it.
This post is a forensic look at the "Lethal Trifecta" of agentic AI: Root access, untrusted content exposure, and missing gates.

value: Show HN: From Clawdbot to OpenAI: Dissecting the supply chain that sold out

author: agentic-wiki


value:
Hey HN, Sascha here, developer of OkaiDokai. Like many others, I fell in love with OpenClaw, but was longing for more control over what it can do without interrupting its autonomous, agentic nature. OkaiDokai solves this for me by allowing me to set up my own rule set of what is allowed by default, what is not, and what it should ask permission for. It comes with a hosted API, web and native apps including push notifications (with quick-response support), plugins for OpenClaw and Claude Code, and soon Codex.
I'm still working on getting the apps onto the App Store (currently on TestFlight and Android beta channels), as well as giving the rule engine and UI a bit more love. It should be good enough for a quick test if anyone dares to try it!
I just created a new Discord server (https://discord.gg/M25cCwJ5x7), so please say "hello" if you’d like to give it a go and provide me with any feedback you have. I'm adding new features and improvements pretty much around the clock right now. I'm also planning to release the source code under the Sustainable Use License soon, as I think it's important to get more eyes on it and allow others to contribute should they want to.
Thanks for reading :)

value: Show HN: OkaiDokai, tool-level firewall for OpenClaw, Claude Code and Codex


value: Contenagent

value: Show HN: E-Rechnung Push – E-Invoicing for German SMBs (ZUGFeRD/XRechnung)

author: Contenagent


value: ijonis

value: Show HN: Geo-lint – open-source linter for GEO (AI search visibility)

author: ijonis


value: WolfOliver

value: Show HN: LinkedRecords – A Server-Sovereign Alternative to Firebase

author: WolfOliver


value: Gregoryy

value: Built google-drive-cli-for-agents: a small Python CLI for Google Drive.<p>It supports ls by folder link/ID, file upload, download, and trash by link/ID, with OAuth login (gdrive auth login) and pipx install support.

value: Show HN: Google Drive CLI for LLMs / Coding Agents

author: Gregoryy


value: Tjerkienator

value: Show HN: Lobster Sauce – the most recent OpenClaw news in one central place

author: Tjerkienator


value: Show HN: AgentBouncr – Governance layer for AI agents


value: primaprashant

value:
I ran a hands-on workshop in Tokyo where ~50 engineers built a CLI coding agent from scratch in Python. I've converted it into a self-paced exercise.
GitHub Repo: https://github.com/primaprashant/alduin
We start from a skeleton repo with a basic input loop and no LLM. Over seven phases, we add the Anthropic API, implement tools (read file, edit file, bash), and build the core agent loop.
Each phase has hints and a reference commit if you get stuck.

value: Show HN: A Self-Paced Exercise to Build a CLI Coding Agent from Scratch

author: primaprashant


value: remocode

value:
Hi HN,
I built remote-opencode, a Discord bot that runs on your dev machine and lets you use your local OpenCode CLI from anywhere (phone/tablet/another laptop).
It streams output back into Discord threads, supports queuing follow-ups, and can spin up per-task git worktrees with a PR button.
Repo & Demo: https://github.com/RoundTable02/remote-opencode

value: Show HN: Remote-OpenCode – Control your AI coding assistant from Discord

author: remocode


value: cong-or

value: Show HN: Hud – eBPF-based blocking detector for Tokio

author: cong-or


value: jbwagoner

value: Show HN: Samma Suit – 8 enforced security layers for AI agents (open source)

author: jbwagoner


value: emirce

value:
Hello HN-Friends!
I wanted to share ClawShip with you, a platform that allows non-technical people to deploy their 24/7 OpenClaw agent to the cloud with one click.
All of the technical stuff such as setting up a VPS, firewalls, SSH, Docker, API keys etc. is taken care of. Deployment ready in no time.
Let me know what you think :)
URL: http://useclawship.com

value: Show HN: ClawShip – Deploy OpenClaw to the cloud with one click

author: emirce


value: primerpy

value:
Can also read in medium for free
https://medium.com/@primerpy/introducing-mcp-backpack-persis...
I built a light mcp that persists memory for Claude Code in 138 lines of Python, without using redis or vector DB. Also it can export and restore memories among different computers.

value: Show HN: I built a lightweight memory layer for Claude Code

author: primerpy


value: astonfred

value: Show HN: Lightweight web analytics – one line of JavaScript, no cookies

author: astonfred


value: afuno

value:
Ruby's flexibility is great until every developer on the team writes service objects differently. After years of working with Rails codebases where each service had its own structure, error handling, and testing conventions, I built Servactory — a framework that standardizes service objects through a typed, declarative DSL.
The core idea is three separate attribute layers: inputs (what comes in), internals (working state), and outputs (what goes out). Each is a distinct declaration with its own namespace and type checking. Combined with declarative make calls that define action order, the data flow through a service is visible at a glance:

  class Payments::Process < ApplicationService::Base
    input :payment, type: Payment

    internal :charge_result, type: Servactory::Result

    output :payment, type: Payment

    make :validate_status!
    make :perform_request!
    make :handle_response!
    make :assign_payment

    private

    def validate_status!
      return if inputs.payment.pending?

      fail!(
        message: "Payment has already been processed",
        meta: { status: inputs.payment.status }
      )
    end

    def perform_request!
      internals.charge_result = Gateway::Charge.call(
        amount: inputs.payment.amount,
        token: inputs.payment.token
      )
    end

    def handle_response!
      internals.charge_result
               .on_success { handle_success! }
               .on_failure { handle_failure! }
    end

    def handle_success!
      inputs.payment.complete!(internals.charge_result.response.id)
    end

    def handle_failure!
      inputs.payment.fail!(internals.charge_result.error.message)
      fail_result!(internals.charge_result)
    end

    def assign_payment
      outputs.payment = inputs.payment
    end
  end

What I think makes it worth trying:
- Type safety on all three layers — inputs, internals, and outputs are each type-checked independently
- Explicit data flow — the separation into three namespaces (inputs., internals., outputs.*) eliminates "where does this value come from?" confusion
- Structured failure handling — fail! with metadata, typed failures, fail_result! for error propagation, on_success/on_failure hooks on the result
- Action grouping — stage blocks with wrap_in for transactions, only_if conditions, and rollback handlers
- Full ecosystem — custom RuboCop cops, OpenTelemetry instrumentation, RSpec matchers, Rails generators
Supports Ruby 3.2+ and Rails 5.1 through 8.1. 110K+ gem downloads, 138 releases, MIT licensed. I've been using it in production for over two years.
Would love to hear feedback, especially from people who've tried other approaches (Interactor, ActiveInteraction, Trailblazer, or plain POROs).
Docs: https://servactory.com

value: Show HN: Servactory – Typed service objects with declarative actions for Ruby

author: afuno


value: marcelglaeser

value: Show HN: HowYouCode – Developer fingerprint from real code analysis

author: marcelglaeser


value: zahirbmirza

value:
I built an app for wellness tracking that keeps your data local; no cloud uploads or processing required.
I wanted a place to store my own info and share it on my own terms. For example, I might want to share that I'm feeling good with friends, or bring a summary of my blood pressure readings to a doctor's appointment. The main concept is personally owned data collation rather than handing everything off to a third party. Also, I think recording stats in a place other than a notes app would allow for better analysis and visualisation options in the future.
I do want to develop this app further, and am keen on understanding what others would want from a tracking app.
Potential use cases:
Tracking wellness to mood
Having data from multiple sources being personally organised and managed
Sharing customised info/stats
The big players in this space sometimes trade privacy for polish. I wanted something where the tradeoff goes the other way. More polish will come to StatusHealthy (I think that could be better).
Critical feedback would be appreciated. What is a feature of such an app that would want you to check in regularly? I am eager to hear any thoughts. Thank you.

value: Show HN: On Device Personal Wellness Tracking

author: zahirbmirza


value: bekirdag

value:
Hi HN,
I use LLMs every day for software development, and wanted to have a better experience by reducing the token usage and providing digested information about the codebase to the agent.
So I built Docdex. The idea was simple: a local, persistent layer that preprocesses and structures your project so the model can spend its context window on the actual problem, not on rediscovering what already exists.
It started as a document indexer in Rust, built on Tantivy for proper ranked full-text search.
Then it kept growing. I added code search, AST-based symbol indexing, a directed symbol graph for impact analysis ("what breaks if I change this function?"), repo memory for project-level facts, and agent memory so the LLM can persist preferences across sessions.
One architectural decision I'm particularly happy with: it runs as a single daemon. MCP servers have a habit of getting stuck, each tool call spawning processes, LLMs not cleaning up after themselves, multiple SSE connections fighting over resources. Running everything as one lightweight background service sidesteps most of that. It handles multiple repos, re-indexes on changes, and stays out of the way.
I also added web search, but handled locally. During setup it can install Ollama, pull `nomic-embed-text` for embeddings, and optionally `phi3.5` for lightweight reasoning. Search results get scored and filtered locally before anything hits a paid API. Brave Search works best, but Google/Bing work too with API keys.
There's also job delegation, expensive frontier models can offload simpler subtasks to a local Ollama model, which cuts paid token usage noticeably in practice.
Supported languages for impact graph reasoning: Rust, Python, JS/TS, Go, Java, C++, and more.
You can also use it standalone, as a local search engine for your docs, a plain HTTP server, or a web search and summarization tool. It's not glued to any particular AI workflow.
How to install:
npm i -g docdex
Setup:
docdex setup
Website: https://docdex.org, Repo: https://github.com/bekirdag/docdex
Fully open source, free to use. API keys for web search are optional.
It's genuinely made my daily dev workflow better, fewer tokens, more consistent answers, less time reexplaining things. I plan to keep developing it and may eventually offer optional paid services (like delegated cloud model jobs via OpenRouter), but the core will stay open.
Would love feedback, especially from people building serious AI dev tooling.

value: Show HN: Docdex – A local tool to reduce LLM tokens and make agents smarter

author: bekirdag


value: Dicemanx

value:
Hi HN
Today we are launching Groundwork (https://www.groundwork.today), but before getting into the platform itself, I want to share the macro thesis that led us to build it.
The Macro Shift: The "Time Surplus"
When you look at the history of human labor, it isn't a linear progression from toil to leisure—it's actually U-shaped.
Historically, hunter-gatherers worked only 15–20 hours per week on subsistence. We are currently exiting a 200-year anomaly of extreme work hours (the Industrial Revolution) and returning to a baseline of intermittent labor.
Generative AI is accelerating this by automating "cognitive drudgery." With massive productivity gains, the data indicates we are structurally moving toward a reduction in the standard workweek, with 32 hours (or eventually less) emerging as a new economic equilibrium. This creates a massive "Time Surplus" for the average knowledge worker.
Our research shows that people don't just want to spend this surplus on leisure; they want to invest a portion of it into purpose and impact. We are already seeing the value of a volunteer hour rise to nearly $35, reflecting a shift from manual contributions to highly skilled work.
The Problem: The Engagement Gap
Despite this growing "Cognitive Surplus," the infrastructure to deploy it is broken.
You wouldn't ask a surgeon to fix a sink, so why are volunteers stuck doing generic data entry if their superpower is data science, full-stack development, or graphic design?
Millions of people want to make a tangible impact on global and local issues, but they stay on the sidelines because they don't know where their time can make an impact towards causes they care about. The barrier isn’t a lack of intent; it’s the friction of discovery. At the same time, non-profits and impact organizations struggle with high volunteer drop-off rates because they default to a "general labor" model.
The Solution: Groundwork
We built Groundwork to solve this exact inefficiency. We are replacing the traditional "search for a role" model with precision matching.
The Onboarding: Volunteers spend 3 minutes sharing their personal values, specialized skills, and time availability.
The Matching: We connect volunteers with impact organizations based on 20+ criteria, prioritizing deep cause alignment (e.g., climate, education, healthcare), schedule syncing, and specific technical or functional expertise.
The Result: Instead of searching endless job boards, we curate the role for the volunteer. You receive direct invitations to opportunities that fit perfectly. On the flip side, impact organizations get access to a high-intent volunteer pool and ready-to-go specialists, drastically increasing their efficacy.
By aligning volunteer values with specific causes and matching their actual skills and availability, we significantly reduce drop-off rates and ensure that every hour of work makes a structural difference.
We’d love for this community to poke around the site (https://www.groundwork.today) and let us know what you think. We are especially interested in your feedback on our macro thesis regarding the "Time Surplus" economy.
Happy to answer any questions!

value: Show HN: Groundwork – Organizing the AI-Driven "Time Surplus" for Impact

author: Dicemanx


value: PrimeStark

value:
Hey HN. I built a free accessibility scanner that checks 33 WCAG 2.1 criteria against any URL.
CLI: npx accessiguard scan your-site.com
GitHub Action: github.com/PrimeStark/accessiguard-action (posts a11y report on every PR)
I was an engineering manager who got frustrated watching teams skip accessibility because audits cost $500+ and took weeks. So I built something you can run in 30 seconds from your terminal.
Free tier, no signup for single scans. Would love feedback on what checks to add next.
https://accessiguard.app

value: Show HN: AccessiGuard – Free WCAG Scanner with CLI and GitHub Action

author: PrimeStark


value: Generate personalized content based on the current environment (weather, time, date, and solar terms) via backend LLMs (DeepSeek / Qwen / Kimi) for display on a 4.2-inch E-ink screen.

value: Show HN: InkSight – An open-source, LLM-powered e-ink display for "slow info"


value: jstanley

value: Show HN: ChatJimmy Ultra (100k+ tokens/sec)

author: jstanley


value:
Hi HN —
Today's AI agent guardrails are almost entirely post-hoc. The model proposes an action, then a policy layer tries to reject it. Prompt injection, jailbreaks, and edge cases mean the dangerous action is always one bypass away.
hibana-agent takes a different approach: dangerous actions (purchases, payments, infra changes) are not "blocked" — they are structurally unreachable. The execution path to the dangerous send literally does not exist in the compiled program unless the human-approval branch is taken. This is capability removal at the type level, not prompt-level persuasion.
Concrete demo: an AI agent browses freely, but add-to-cart requires a typed approval gate. The approval is a session-type branch — if the resolver selects "skip", there is no valid code path that reaches the add-to-cart send. Not at runtime, not through injection, not through any prompt trick. The code to execute it is simply not reachable.
A second demo shows enterprise expense approval with parallel Policy/Risk review, checkpoint/rollback, and explicit cancel semantics — all defined as one choreography.
Under the hood this is built on Hibana (https://github.com/hibanaworks/hibana), an Affine Multiparty Session Type runtime for Rust. The protocol is defined once, projected per role at compile time, and each step is consumed exactly once. But you don't need to know any of that to see the value: your agent physically cannot do what the protocol doesn't allow.
Would love feedback, especially from anyone building agent systems where a single wrong action is high-cost.

value: Show HN: AI agent framework where dangerous actions are structurally unreachable


value: erysngl

value:
I created this simple bookmarklet because I was tired of the "Video paused. Continue watching?" prompt on YouTube Music.
The challenge was YouTube's strict Content Security Policy (CSP) and TrustedHTML requirements, which break most innerHTML based scripts. I built this using pure DOM elements (document.createElement) to bypass these restrictions natively without needing a heavy browser extension.
It's open-source and features a draggable UI. I'd love to hear your thoughts on the code and the approach!

value: Show HN: YTM Keep-Alive –A lightweight bookmarklet to bypass YouTube music pause

author: erysngl


value: Show HN: Free AI SEO Content brief generator


value: redclaw

value:
Clawbernetes turns OpenClaw into an AI-native infrastructure manager. Instead of YAML, Helm charts, and kubectl — you have a conversation.
"Deploy Llama 70B on the node with the most VRAM" → agent selects the best node, pulls the image, starts the container with GPU passthrough, sets up health monitoring.
"Why is inference slow?" → checks GPU temps, VRAM, CPU load. "GPU 0 at 89°C — thermal throttling. Want me to reduce batch size?"
23 crates, 74K lines of Rust, 1,866 tests, zero unsafe in core. Supports CUDA, Metal, ROCm, Vulkan, and CPU SIMD.
Components:
- clawnode: node agent with 80+ commands (deploy, secrets, autoscale, networking, jobs, metrics)
- 14 skills that teach the AI agent infrastructure ops
- Fleet plugin for multi-node orchestration
- MOLT: P2P GPU compute marketplace (Solana SPL)
MIT licensed.
https://clawbernetes.com
https://github.com/clawbernetes/clawbernetes

value: Show HN: Clawbernetes – Replace kubectl with conversation (Rust)

author: redclaw


value: jimishol

value:
OP here.

    This is a geometric decoding of Chopin's Prelude No. 4.

    I built a 3D music midi visualizer ( https://github.com/jimishol/cholidean-harmony-structure ) and realized that standard music theory couldn't explain the shapes I was seeing. So, I developed the Umbilic-Surface Grammar to map the topology of the harmony.

    This document demonstrates that the prelude's tension isn't random, but a rigorous conflict between 'Gravity' (Station Shifts) and 'Will' (Pivots).

    I am looking for feedback on the logic—specifically from anyone with a background in topology or music theory. Does this geometric proof hold up?

value: Show HN: A geometric analysis of Chopin's Prelude No. 4 using 3D topology

author: jimishol


value: Show HN: Claude Code Open – AI Coding Platform with Web IDE and 37 Tools


value: Mikheyrojo

value:
I built a small Claude Code plugin that sends Telegram messages when Claude finishes a task or needs permission to proceed.
It's a shell hook that calls the Telegram Bot API — no daemon, no dependencies, ~50 lines of shell. Useful when you run multiple Claude sessions across different terminals/IDEs.
Setup: create a Telegram bot, install the plugin, add credentials. Takes ~2 minutes.
Free and open source.
https://github.com/mikhailrojo/claude-telegram-notifications

value: Show HN: Claude Code plugin – Telegram notifications when it needs your input

author: Mikheyrojo


value:
When you ask an AI a legal question, it doesn't look anything up. It generates an answer from patterns in training data. It sounds confident, uses the right terminology, and is often mostly right, which makes it dangerous, because you can't tell which parts are wrong. It's like asking a lawyer to cite from memory. They may get close, but it's not accurate enough.
We built open-source MCP servers that fix this. Instead of answering from memory, the AI queries our server, retrieves the exact statutory text from official government databases, and cites the specific article. Real text, real source, verifiable.
20 servers live, all Apache 2.0:
National law for 15 countries (NL, DE, SE, SI, DK, FI, NO, IS, UK, IE, BE, LU, FR, AT, US)
49 EU regulations (GDPR, NIS2, DORA, AI Act, CRA, MiCA)
US federal and state regulations (HIPAA, CCPA, SOX, GLBA)
1,451 security controls mapped across 28 frameworks
All sourced from official government databases — wetten.overheid.nl, gesetze-im-internet.de, legislation.gov.uk, Riksdagen, and more.
The goal is to cover every jurisdiction in the world. Law is public information, but it's still surprisingly hard to access programmatically. We want to change that.
We built a lot of these for our security intelligence platform, but figured the open data parts really should be for everyone. One of our biggest goals is to make security that's only accessible to big corporations accessible to everyone, especially public services and government.
GitHub: https://github.com/ansvar-systems
All endpoints: https://ansvar.eu/mcp

value: Show HN: Open-source MCP servers making every country's law searchable by AI


value: vtemian

value: Show HN: Export and resume Claude Code sessions

author: vtemian


value:
Hi HN,
I built LexPrep during my Master’s in Cognitive Neuroscience because preparing lexical datasets for reading experiments was taking me hours every week.
Most NLP libraries I tried were powerful but too general for psycholinguistics workflows. I needed something focused on experimental stimulus control rather than large-scale text processing.
LexPrep currently supports:
• Syllable counting
• Grapheme-to-phoneme (G2P)
• Orthographic neighborhood calculation
• Lexical statistics for stimulus control
• Multi-language support (Persian, English, Italian)
The goal is reproducible and fast stimulus preparation for cognitive and reading experiments.
I’d love feedback from the HN community. especially around API design, performance, and potential integrations.
Repo: https://github.com/sajjad-mazaheri/lexprep

value: Show HN: LexPrep – Open-source toolkit for linguistic stimulus preparation


value: IronsideXXVI

value:
Hey HN! I built a native macOS desktop client for Hacker News and I'm open-sourcing it under the MIT license.
GitHub: https://github.com/IronsideXXVI/Hacker-News
Download (signed & notarized DMG, macOS 14.0+): https://github.com/IronsideXXVI/Hacker-News/releases
Screenshots: https://github.com/IronsideXXVI/Hacker-News#screenshots
I spend a lot of time reading HN — I wanted something that felt like a proper Mac app: a sidebar for browsing stories, an integrated reader for articles, and comment threading — all in one window. Essentially, I wanted HN to feel like a first-class citizen on macOS, not a website I visit.
What it does:
- Split-view layout — stories in a sidebar on the left, articles and comments on the right, using the standard macOS NavigationSplitView pattern.
- Built-in ad blocking — a precompiled WKContentRuleList blocks 14 major ad networks (DoubleClick, Google Syndication, Criteo, Taboola, Outbrain, Amazon ads, etc.) right in the WebKit layer. No extensions needed. Toggleable in settings.
- Pop-up blocking — kills window.open() calls. Also toggleable.
- HN account login — full authentication flow (login, account creation, password reset). Session is stored in the macOS Keychain, and cookies are injected into the WebView so you can upvote, comment, and submit stories while staying logged in.
- Bookmarks — save stories locally for offline access. Persisted with Codable serialization, searchable and filterable independently.
- Search and filtering — powered by the Algolia HN API. Filter by content type (All, Ask, Show, Jobs, Comments), date range (Today, Past Week, Past Month, All Time), and sort by hot or recent.
- Scroll progress indicator — a small orange bar at the top tracks your reading progress via JavaScript-to-native messaging.
- Auto-updates via Sparkle with EdDSA-signed updates served from GitHub Pages.
- Dark mode — respects system appearance with CSS and meta tag injection.
Tech details for the curious:
The whole app is ~2,050 lines of Swift across 16 files. It uses the modern @Observable macro (not the old ObservableObject/Published pattern), structured concurrency with async/await and withThrowingTaskGroup for concurrent batch fetching, and SwiftUI throughout — no UIKit/AppKit bridges except for the WKWebView wrapper via NSViewRepresentable.
Two APIs power the data: the official HN Firebase API for individual item/user fetches, and the Algolia Search API for feeds, filtering, and search. The Algolia API is surprisingly powerful for this — it lets you do date-range filtering, pagination, and full-text search that the Firebase API doesn't support.
CI/CD:
The release pipeline is a single GitHub Actions workflow (467 lines) that handles the full macOS distribution story: build and archive, code sign with Developer ID, notarize with Apple (with a 5-retry staple loop for ticket propagation delays), create a custom DMG with AppleScript-driven icon positioning, sign and notarize the DMG, generate an EdDSA Sparkle signature, create a GitHub Release, and deploy an updated appcast.xml to GitHub Pages.
Getting macOS code signing and notarization working in CI was honestly the hardest part of this project. If anyone is distributing a macOS app outside the App Store via GitHub Actions, I'm happy to answer questions — the workflow is fully open source.
The entire project is MIT licensed. PRs and issues welcome: https://github.com/IronsideXXVI/Hacker-News
I'd love feedback — especially on features you'd want to see. Some ideas I'm considering: keyboard-driven navigation (j/k to move between stories), a reader mode that strips articles down to text, and notification support for replies to your comments.

value: Show HN: A native macOS client for Hacker News, built with SwiftUI

author: IronsideXXVI


value: Frameser

value:
It’s a modern FTXUI-based terminal editor—like Nano and Sublime’s baby. No weird modal editing, no 100+ shortcuts to memorize, just useful features with a non-eye-glazing UI.
Here’s why it’s my daily coding/note-taking editor:
•Zero learning curve. Ctrl+S/Ctrl+Z/Ctrl+F—all standard shortcuts you know. No more 2 AM “how to exit Vim” searches.
•Looks great. 28 themes (Monokai, Dracula, Nord, etc.), toggleable line numbers, current line highlighting, and a clean 3-column layout.
•Surprisingly powerful. Multi-tab support, regex search/replace (live previews!), syntax highlighting for major languages (C++, Python, JS, etc.), and LSP for code completion/error checks.
•Super lightweight. Terminal-based, fires up instantly—no VS Code bloat. Runs smooth even on old laptops.
I know we all have go-to editors (shoutout Neovim fans), but if you’re tired of “too simple” vs “too complex,” try pnana. Early (v0.0.4), but more polished than most terminal editors.
Building is simple—clone, run the build script, done. No messy dependencies (clear docs if you hit snags).
Bonus: Split editing and Lua plugins are coming. I’ve used it nonstop for a week—no plans to go back.
Check it out: github.com/Cyxuan0311/PNANA
Curious your thoughts—tired of terminal editor tradeoffs? Does this fill a gap?

value: Show HN: A TUI text editor built by FTXUI

author: Frameser


value: alohaTool

value:
I built NotesGutter for VS Code, Cursor etc to stop "comment rot." Instead of 20-line comments cluttering your source, you attach rich Markdown notes and Excalidraw diagrams to specific lines via small anchors.
The Workflow:
Markdown Side-Peek: High-fidelity documentation for complex logic.
Infinite Canvas: Draw architecture diagrams directly linked to functions.
Git-Native: Notes are stored in a .notesgutter folder. They version with your code and work 100% offline.
Privacy: No cloud. No tracking. Your data stays in your repo.
Preview: https://github.com/ParasKoundal/NotesGutter/raw/main/Preview...
Install: Search "NotesGutter" in the VS Code/Cursor/Antigravity Marketplace
or find it here:
https://marketplace.visualstudio.com/items?itemName=ParasKou...
https://open-vsx.org/extension/ParasKoundal/notesgutter
I'd love to hear what you think about it : https://github.com/parasKoundal/NotesGutter.

value: Show HN: NotesGutter – Clean Code Notes with Markdown and Drawings

author: alohaTool


value:
I’ve just released "Value of the day" — An Experimental website project to rate each day with stars and reviews.
The website functions like a collective diary, where the "value" of each day is determined by its average star rating and a repository of anonymous reflections.
The calendar on each page displays the average star rating for that day, and once you've posted, you can click on the date to see the review details.
Posts can be made from the post page. Posts are made with just the star rating and review, and are all posted anonymously.
In a world where everything—from Amazon products and Yelp reviews to our very behavior on Uber—is reduced to a five-star metric, and the "average" is treated as the ultimate truth. This project is an experiment in applying that same system to the most fundamental unit of our lives: a single day.
I wanted to explore the "cost" of shared data in our rating society. To maintain the integrity of the experiment, I implemented a strict exchange: you can only access the collective average and see others' reflections once you have surrendered your own "value" for the day.
Our website is responsive. The UI is intentionally clinical and minimalist, removing as many unnecessary elements as possible to focus on the data itself.
I’m curious to hear your thoughts: in an age of constant quantification, what does the "average" of our collective days actually represent? Is it just noise, or truth?
I’m happy to answer any questions you might have, whether they’re about the development process, the tech stack, or my design decisions.

value: Show HN: Value of the Day – Rate your day with stars and reviews


value: jbingen

value: Show HN: tnnl - Self-hosted ngrok alternative with request inspection and replay

author: jbingen


value: QuiCreatDev

value: Hi HN, I was tired of managing Puppeteer instances crashing my Docker containers every time I needed to take a screenshot of a modern SPA. So I wrapped an optimized Chromium layer into AWS Lambda, added smart waiting for lazy-loading, and turned it into an API. Would love your feedback on the architecture!

value: Show HN: I built a serverless API for automated website screenshots

author: QuiCreatDev


value: oliverjanssen

value:
Hey HN, instant bank transfers are free now in Europe. So why do I still need PayPal to send someone 20 bucks? Especially when some providers share your transaction data with up to 600 companies. I just want to send money to a friend - not opt out of 600 ad partners one by one. The only annoying part: IBANs are 22+ characters and impossible to remember.
So I built iban.link. You get a short page (like iban.link/lisa) that shows your name, IBAN, and a scannable EPC QR code. Anyone can copy the IBAN or scan the QR directly with their banking app.
You can prefill amount and reference: iban.link/lisa#amount=25&ref=Pizza - uses hash fragments so the payment details never hit the server.
Stack: Bun, Hono, PostgreSQL, vanilla JS. No React, no bundler. Data encrypted at rest (AES-256-GCM).
Hope it's useful to some of you. Questions, ideas, feedback? Happy to hear it.
If you want to try it, feel free: iban.link/oliverjanssen#amount=20&ref=HN ;)

value: Show HN: Iban.link – A memorable link for your IBAN

author: oliverjanssen


value: Keeeeeeeks

value:
I built a self-hosted dashboard for keeping tabs on AI agents (Claude Code, OpenCode, Codex, etc.) while they work. It's a Next.js app backed by SQLite that runs on a headless Mac Mini and is accessed over Tailscale.
Agents POST status updates to a REST API. You get a drag-and-drop Kanban board with 6 status columns, parent/child task hierarchy (3 levels deep), comments, sprint management, velocity tracking with burndown charts, and 7 analytics chart types. Messages are encrypted at rest with NaCl secretbox.
The whole thing binds to 127.0.0.1 — nothing touches the open internet. Tailscale Serve handles HTTPS. No Postgres, no Redis, no Docker. Just SQLite and a Node process.
It's deliberately passive: the dashboard shows you what agents are doing, it doesn't orchestrate them. No auto-retries, no task reassignment, no unsupervised autopilot. You still have to check in.
What I want to build next: a unified message queue so any IDE terminal can push events without custom hooks, SSE to replace polling, and a proper notification pipeline for blocked tasks.
Repo: https://github.com/Keeeeeeeks/opencode-dashboard

value: Show HN: OCD – Open-source Kanban dashboard for monitoring AI coding agents

author: Keeeeeeeks


value: ethanYIAI

value: Normal map generator online. Convert any image into detailed, high-quality normal maps instantly. Free, fast, and easy to use.

value: Show HN: Normal Map Generator Online

author: ethanYIAI

title: Show HN: Normal Map Generator Online


value: elesinn

value:
I kept losing focus not because I lacked discipline, but because starting a focus session had too many steps: open the task app, pick a task, open a separate timer, set the duration, start. By step 3 I was already on Twitter.
So I built Focusmo — a native macOS app that pulls tasks from the tools you already use (Things, Todoist, TickTick, Reminders, Google Tasks, Microsoft To Do, Obsidian) and lets you start a timed focus session on any task in seconds.
The core idea: your task list and your focus timer should be the same app.
What it does:
- Connects to 7 task managers so you don't maintain a separate list
- Command palette (like Raycast) — keyboard shortcut, type task name, hit enter, you're working
- Floating timer that stays visible across spaces and monitors
- Pomodoro mode with automatic work/break cycles, or a "minimum goal" mode that keeps going if you're in flow
- Activity tracking that shows which apps you used during sessions (no keylogging, all local)
- Workspaces with app blocking — define "deep work" vs "meetings" environments
- Streaks and achievements that celebrate, never punish
It's a native SwiftUI app, not Electron. Runs as a menu bar app or a regular window.
I've been building this solo for about two years. Happy to answer questions about the architecture, the integrations, or the product decisions.

value: Show HN: Focusmo – A macOS focus timer that connects to your existing task apps

author: elesinn


value:
Hey HN,
I got incredibly tired of RAG for code. Vectorizing source code into arbitrary chunks and hoping a cosine-similarity search finds the right structural context is a black box that just doesn't reliably work for agentic coding. It's anti-KISS.
So I wrote AstrMap in Go.
It rips through your repo in milliseconds and generates a highly compressed, AI-readable AST "Map" (like a giant table of contents with line numbers and functions). You feed the Map to your LLM (costs almost 0 tokens), and the LLM uses it as a deterministic radar to pinpoint exactly which files it needs to modify. It treats your architecture as pure, parseable text.
It's completely free, a single binary, local, and supports Go, JS/TS, Python, HTML/CSS. Give it a try and let me know if it speeds up your agentic coding workflows.
Link: https://github.com/hubby247/astrmap

value: Show HN: AstrMap – Unix Philosophy for the AI Era (Ditch the RAG)


value: helloiamvu

value:
Hi HN, we built a better search for Kalshi and Polymarket.
There are about 80k active contracts across both platforms right now. Real-time probability estimates for everything from tonight's NBA games to whether Bitcoin will be up in 5 minutes. But the data is fragmented with no unified way to search it.
We trade prediction markets everyday and needed a smarter way to search across all of them. We started by ingesting everything into Postgres and writing SQL. Then we built a Claude wrapper that queries the DB in plain English. Type a question, get structured results. That actually worked and felt like what search should be. But the answers were only as good as the data, and the data was a mess.
The core problem: Both platforms structure their data completely differently. One NBA game on Kalshi is dozens of separate contracts, each with its own ticker. Polymarket has the same game as a handful of contracts with different naming. One says "Cleveland," the other says "Cavaliers." You can't search across any of it without cleaning it up first.
So we built a pipeline to clean the data and classify it properly. Every market goes through it. Structured parsing for the predictable stuff, LLM for free-form titles/description the rules can't handle. New markets get picked up and classified within minutes. Not glamorous work but it's what makes the search return the right stuff instead of garbage.
Some things you can try:
- "NBA tonight" - games from both platforms resolving today
- "Zelensky markets on Polymarket" - filtered to one platform
- "Weather in Chicago today" - Kalshi has an entire weather derivatives market
- "Kalshi trending" - sorted by volume
- "pokemon" - you'd be surprised what people bet on
Groupings aren't perfect, some labels are messy. But we use it every day for our own trading and fix things as we run into them. Would love your feedback.
https://www.attena.xyz/

value: Show HN: Natural language search across Kalshi and Polymarket

author: helloiamvu


value: Mnexium

value:
Today we’re open-sourcing the core memory engine behind Mnexium.com : CORE-MNX
GItHub (https://github.com/mnexium/core-mnx)
NPM (https://www.npmjs.com/package/@mnexium/core)
For us, this is a product decision and a philosophy decision.
Memory infrastructure is becoming foundational for serious AI products, and we believe the core layer should be transparent, inspectable, and extensible by the teams building on top of it. We also just want feedback - we want to build the best memory system given the tools we have access to today. We also want to make LLMs perform better then they already do OOTB.
CORE-MNX is the backend layer that powers durable memory workflows:
    memory storage and retrieval,
    claim extraction and truth-state resolution,
    memory lifecycle management, and event streaming for real-time systems.
    It’s Postgres-backed, API-first, and built to integrate into real production stacks.
We tried our best to make this system as standalone as possible. Ultimately, its fairly difficult we needed LLMs (Cerebras for fast token output, ChatGPT for intelligence etc), Databases for storage etc. We have intentionally made the project API interfaced so your project can be code agnostic.
Open-sourcing CORE lets builders:
    understand exactly how memory behavior works,
    self-host or extend the engine for their own products,
    and avoid reinventing the same memory infrastructure from scratch.
What stays on Mnexium.com
Mnexium’s long-term direction is still the same: make AI systems more useful over time through durable memory and reliable recall. We've just figured out that hosting memory isnt the moat we once thought it was - the real moat we believe is making the LLM system(s) as easy to use as possible. The feature-set we've built around memory is what is differentiating.
Open-sourcing CORE is how we make that foundation available to everyone building in this space. Open to everyone to lend an opinion on improvements and how we make this problem solvable.
Would love feedback, opinions and bugs you may find. We release it isn't perfect, but certainly a good start we'd love to improve upon.

value: Show HN: OSS Durable Memory for LLMs

author: Mnexium

title: Show HN: OSS Durable Memory for LLMs


value: ossa-ma

value:
Today I come to you on this beautiful Friday with a freshly hardthink-ed solution to a proliferous problem plaguing our world: the loss of original voice. The blanket of blandness slowly suffocating centuries of writing.
Or to put it bluntly: AI writing is trash.
It is disrespectful to expect ME to read something YOU could not even be bothered to write (or likely even read).
The lingering human connection that remained resilient on the internet - through
years of SEO optimisation, propaganda bots, ads, regional firewalls, politics, censorship - is now being diluted even further.
Many of the posts I eagerly click on HN (especially sorting by new) are now disappointingly, ragingly, completely AI generated.
This includes several that reach the front page on a daily basis. It's shameless.
Unfortunately, many of you educated readers are oblivious to the tropes and tells or too eager to discuss the topic to notice.
To combat this (and because I'm petty) I (and ironically Claude) built a directory and several tools to name and shame these patterns. Both to educate those are not AI-literate and to spread awareness. NOT TO HARASS.
tropes.fyi is a catalogue of the recurring tropes, tics, structures and word choices that give away AI-generated writing. Each trope is documented with a name, description, real-world examples and the category it falls under (word choice, sentence structure, tone, formatting, composition).
There are currently 32 tropes. Some highlights:
- Negative Parallelism: "It's not X — it's Y." The SINGLE MOST COMMON AI writing tell. One per piece is fine. Ten in a blog post is insulting. AND I HAVE SEEN TEN IN A BLOG POST.
- Tricolon Abuse: The compulsive rule of three. "Products impress people; platforms empower them. Products solve problems; platforms create worlds."
- Em-Dash Addiction: A beautiful punctuation. Once the sign of a brilliant writer now too many of these is a red flag. I still use them, you won't break my spirit.
- "Delve" and Friends: Perhaps the most infamous. "Delve" went from uncommon to appearing in a staggering percentage of AI text. See also: "leverage", "robust", "harness".
full directory: https://tropes.fyi/directory
ai;dr - Paste a link to any article. It will strip the AI fluff using our trope detection rules, then feed the skeleton to a lightweight llm which reverse-engineers it back to the prompt they likely* typed :D.
3000 words of slop → 30-word prompt + whatever unique insights (if any) survived the bloat. try it: https://tropes.fyi/aidr
AI Vetter - Paste a URL, get a verdict. The AI Vetter fetches article content, runs rule-based pattern matching against all 32 tropes and returns a score on the scale: Human → AI-assisted → Suspicious → Barely Legible → Pure AI Slop. try it: https://tropes.fyi/vetter
tropes.md -  A single file you can drop into any AI assistant's system prompt so it avoids these patterns. Sorry for helping them become invisible, I'd just rather not see it.
"You're a hypocrite I'm sure you use AI for writing code!" — AI generated code is fine, it's one computer (LLM) talking to another (compiler). How else do you think AI is so good at writing code? They're speaking the same language! But prose? That's from human to human, it's sacred and meant for other people. Using AI for that is deceitful.

value: Show HN: Tropes.fyi – Name and shame AI writing

author: ossa-ma


value: mcarthey

value:
I built a multiplayer strategy game with no GUI — you play entirely through REST API calls. Register, build a roster, configure teams, queue battles, and climb the leaderboard, all via curl/Postman/your own code.
Every response includes HATEOAS links that guide you to your next move, so you can discover the whole game by following the API. Full OpenAPI spec at /api-docs/v1.
Built with ASP.NET Core 8 and MSSQL. Free tier is fully playable. There's also an education mode for CS instructors to create curriculum modules where students learn APIs by playing.
Solo dev creating for my classes, happy to answer questions about the tech or design decisions.

value: Show HN: API Combat – A game played through API calls

author: mcarthey


value: lastFitStanding

value: Show HN: I built a website for generating viral shorts with AI

author: lastFitStanding


value: dclavijo

value: Show HN: AGP: Ambulatory glucose profile analysis tool

author: dclavijo


value: garagon

value:
  Hey HN,

  I built Aguara because I kept seeing the same problem: AI agents and MCP servers
  run code on your behalf, and nobody is checking what that code actually does before
  it runs.

  A single malicious skill file can exfiltrate your SSH keys, inject prompts to
  override safety instructions, or curl-pipe-bash a backdoor. I wanted something
  like Semgrep but specifically for the AI agent ecosystem.

  Aguara is a Go binary that does static analysis on skill files (markdown,
  YAML, JSON configs). It's offline, deterministic, no LLM, no API keys needed.

  What it catches:
  - Prompt injection (instruction overrides, jailbreaks, delimiter injection)
  - Data exfiltration (webhook URLs, DNS tunneling, env var leaks)
  - Credential leaks (OpenAI/AWS/GCP keys, private keys, DB connection strings)
  - Supply-chain attacks (curl|bash, binary download+execute, unpinned npx)
  - MCP-specific threats (tool injection, privileged docker, shell metacharacters)
  - 138 rules across 15 categories total

  It goes beyond regex — there's NLP-based markdown structure analysis (using
  goldmark AST walking) to catch things like hidden instructions in HTML comments,
  and taint tracking to detect dangerous capability combinations (e.g., a skill
  that reads private data AND has network access).

  I also built Aguara Watch (https://watch.aguarascan.com/) which continuously
  scans 31,000+ public AI agent skills across 5 registries (skills.sh, ClawHub,
  PulseMCP, mcp.so, LobeHub). The scan data is open — you can query any skill's
  security report via a static JSON API.

  Some numbers from scanning the entire public ecosystem:
  - 31,330 skills scanned
  - ~2,330 with security findings (7.4%)
  - 448 critical findings (mostly curl|bash, hardcoded keys, jailbreak prompts)

value: Show HN: Aguara – Security scanner for AI agent skills and MCP servers

author: garagon


value: urip

value:
TLDR: Merge finally brings the Apple Watch to Android. Unlock Apple Watch's cutting-edge health data on your Android phone, synced to any Health Connect compatible app. Get Android notifications on your wrist, reply to messages, control media playback, and more.
Hi all!
I've always believed the best hardware and the best platform should work together, regardless of who made them. Apple Watch has the most advanced health sensors, Android offers unmatched openness and flexibility, and there was no good reason these two couldn't coexist.
So we built Merge for Apple Watch.
Merge connects your Apple Watch to any Android phone for notifications, messaging, media controls, and brings the Apple Watch's cutting-edge health data into the Android ecosystem, to be used with any Health Connect compatible app. Also, for anyone juggling two phones, like a personal iPhone and a work Android, it's the only solution that lets you use your watch for both.
Would love your thoughts and feedback!

value: Show HN: Merge – Connect Apple Watch to Android

author: urip


value:
Streakout is a minimal iOS workout tracker designed to extend Apple Health & Fitness. It reads your existing workout data and turns it into beautiful tiles, charts, and timelines – helping you answer one of the most important questions for your health: “How often did I move this week, this month, this year…?”
Because what really matters is showing up.
There’s no signup, no clutter, no subscription, no data sharing, and no noise – only the most relevant stats and insights, neatly packaged into two simple screens: overview and calendar feed.
Would deeply appreciate some feedback.
LET'S MOVE

value: Show HN: Minimalistic workout tracker for iPhone – Stats, Trends, Streaks


value: gbram

value:
I've been running multiple AI agents (Claude Code, Cursor, Codex) on the same codebase and kept hitting the same problem: they have no idea what each other are doing. Agent A refactors the auth module while Agent B is building a feature that depends on it. Agent C re-investigates a decision that Agent A already made and documented in a different session, but doesn't have access to Agent A's decision making process. Many times I'll have multiple agents running and coming up with different findings that contradict one another since there's no "source of truth" where they can see past decisions that other agents and users made to guide their decision making process... and subsequently burning tokens along the way
The root cause is simple: there's no shared state between agents. Each one starts with a blank slate every session, and when you run them in parallel, conflicts are inevitable.
Hivemind is my attempt at fixing this. It's a persistent, append-only event log exposed as an MCP server. Every agent publishes structured events (decisions, completions, blockers) and every agent can query the log to understand what's happening across the project. I find it most useful when one agent completes a large task, and then my next agent can easily see the updates done instead of scanning through my codebase or git commits, trying to piece together the changes. This alone has saved me tons of session context / tokens.
What it does:
- Shared event log — Agents publish what they're doing and query what others have done. "What auth approach did we decide on?" returns a real answer instead of the agent guessing.
- Advisory file locks — Before editing a file, an agent acquires a lock. If another agent holds it, the edit is blocked with an explanation. TTL-based expiry handles crashes. This alone eliminated most of the conflicts I was seeing. There's also a --no-locks configuration option to disable locking files entirely and then dealing with any potential merge conflicts.
- Semantic search — Events are embedded with vector search, so agents find relevant context by meaning. Searching "login changes" matches "Migrated authentication to JWT" even though no keywords overlap.
- Task state — Active tasks, blockers, and completions are derived from the event stream. Any agent can check what's in progress before starting new work.
- Knowledge base — Persistent project docs that survive across sessions. Architecture decisions, conventions, context that agents need repeatedly.
- Human approvals — Agents can request sign-off before touching critical files. You approve/deny from the dashboard.
How it works in practice:
Install globally (npm install -g @hivemindai/mcp-server), run hivemind login, then hivemind init in your project. It auto-configures your editor's MCP settings and adds coordination rules to CLAUDE.md so agents know to use it.
Would love feedback from anyone running multi-agent workflows!!

value: Show HN: Hivemind – A shared coordination layer for AI agents

author: gbram


value: SavkoDinamitas

value:
I recently finished my graduation project - EagerORM, a lightweight ORM framework positioned somewhere between Hibernate and jOOQ.
The idea was to explore a simpler, more transparent ORM design while still keeping annotation-based entity mapping and relationships. It supports basic CRUD, explicit relation loading, dialect-aware query generation even for more complex SELECT queries, and transaction scoping .
It’s published on Maven Central and fully open source if anyone wants to take a look or try it out:
https://github.com/SavkoDinamitas/EagerORM
Would appreciate any feedback

value: Show HN: EagerORM – A Lightweight Java ORM Between Hibernate and JOOQ

author: SavkoDinamitas


value: AbdullahTarakji

value:
Hi HN! I built PortPilot – a terminal UI that shows all listening ports on your machine, lets you kill processes with one key, and detects port conflicts.
I got tired of typing `lsof -i :3000 | grep LISTEN` 100 times a day while juggling frontend servers, databases, and Redis. Needed something visual but terminal-native.
Built with Go + Bubble Tea. Works on macOS and Linux. MIT licensed.
Features:
- Interactive TUI with real-time updates
- One-key process killing (select, press k, done)
- Search/filter by port or process name
- Conflict detection (highlights when multiple processes fight for same port)
- CLI mode for scripting (portpilot list --json | jq ...)
- Service groups (tag ports as "frontend", "backend", "database")
Also ships as a CLI tool – `portpilot check 3000`, `portpilot kill 8080`, etc.
Would love feedback on the UX and feature requests!
Repo: https://github.com/AbdullahTarakji/portpilot

value: Show HN: PortPilot – A TUI for managing ports and processes

author: AbdullahTarakji


value: shotwellj

value: Show HN: Air Blackbox – Open-source flight recorder for AI agents

author: shotwellj


value: akemmanuel

value: Hey HN. I built a desktop GUI for OpenCode (opencode.ai), the open-source AI coding assistant. Multitasking and orchestration is complicated in the TUI. I wanted to queue prompts while the AI is busy, fork conversations to try different approaches, and revert entire exchanges when things go sideways. None of that fits well in a terminal. OpenGUI is an Electron + React app that wraps OpenCode and adds those features along with multi-project support and live context usage tracking. Built with Bun as the full toolchain. The whole thing was built in about 4 days using Claude and ChatGPT. It's at v0.1.10, works on Linux and macOS, and I use it daily. There are definitely bugs and rough spots. MIT licensed. Would appreciate feedback on the feature set and anything you'd want from a desktop AI coding tool.

value: Show HN: OpenGUI – Desktop GUI for OpenCode with prompt queuing

author: akemmanuel


value: iamalizaidi

value:
Most teams have files where the "why" matters as much as the "what." A config value tuned against prod load. A dependency pinned for a CVE reason. A route that's hardcoded in an external system nobody remembers.
The context exists somewhere — a postmortem doc, a Slack thread, someone's memory. It's just never at the moment a new engineer opens a PR touching that file.
Decision Guardian reads a markdown file of decisions tied to file patterns and posts the relevant context as a PR comment when those files change. Works as a GitHub Action or CLI (npx decision-guardian check, non-zero exit on critical matches).
The part I found interesting to build: simple file matching created too much noise, so I added content-aware rules. A config file only triggers if you change the specific keys that matter.
An alert only fires when both files in a coupled pair change in the same PR. Regex matching on diffs with ReDoS protection and 5s timeout.
{
  "match_mode": "all",
  "conditions": [
    { "type": "file", "pattern": "src/analytics/events.ts" },
    { "type": "file", "pattern": "src/analytics/schema.ts" }
  ]
}
That rule fires only when both files are in the same PR diff — the case where a field rename needs to be consistent across both.
Tech: TypeScript, Trie for O(1) pattern lookup, safe-regex for ReDoS prevention. CLI is platform-agnostic — GitLab CI, Jenkins, any pre-push hook.
GitHub: https://github.com/DecispherHQ/decision-guardian (MIT)
Known gaps: PR commenting is GitHub-only for now. GitLab native support is the most requested thing and the ISCMProvider interface is already stubbed for it.
Happy to discuss the matching engine or the decision format tradeoffs.

value: Show HN: Decision Guardian – surface architectural context

author: iamalizaidi


value: mlapeter

value: Show HN: My 7 year old makes games with AI, I made kidhubb.com to share them

author: mlapeter


value: metadescription

value:
MetaTrader 5 only runs on Windows. The official Python library only works on Windows. If you want programmatic access to market data and order management from a Linux box, your options are Wine (broken), VPS (expensive and annoying), or write MQL5 (a C++ knockoff from 2005 that makes you want to cry).
I wanted to hit an HTTP endpoint from any machine, in any language, and get JSON back.
So I built a Docker container that runs a real Windows 11 VM via QEMU/KVM, boots MT5 in portable mode, and wraps it with a Flask REST API. Multiple brokers and accounts simultaneously, each terminal on its own port.
The VM runs on 512MB real RAM + swap. Sounds cursed, works fine - tiny11 + aggressive debloat idles at ~1.4GB total. I'm running 4 terminals on 2 vCPUs without issues.
The repo ships with a .skills/ file for AI coding agents (OpenClaw etc.) so you can point an LLM at it and tell it to "buy 0.01 EURUSD with a 2 ATR stop" and it figures the rest out.
Also includes a Python TA example with 20+ indicators + Smart Money Concepts (order blocks, FVGs, BOS/CHoCH).

value: Show HN: MetaTrader 5 in Windows via Docker and QEMU/KVM with a REST API

author: metadescription


value: Show HN: Paste any URL → get a product launch video


value: entropyvector

value:
I've been experimenting with agent frameworks and noticed that many workflows reduce to a simple pattern:
- Send input
- Wait for a pattern
- Branch on the match
This is essentially the classic Unix expect model, but applied to LLM conversations.
So I built expectllm — a minimal pattern-matching conversation flow library (365 lines of code).
Example:

    from expectllm import Conversation

    c = Conversation()
    c.send("Review this code for security issues")
    c.expect(r"found (\d+) issues")

    if int(c.match.group(1)) > 0:
        c.send("Fix the top 3")

No chains, no schema definitions, no output parsers.
Features:
- expect_json(), expect_number(), expect_yesno()
- Regex → auto format instructions
- Full conversation history for multi-turn flows
- Auto-detects OpenAI / Anthropic via environment variables
The idea: treat LLM conversations as explicit state machines, where each expect() is a state transition.
Repo: https://github.com/entropyvector/expectllm
PyPI: pip install expectllm
Would love feedback — especially on where this abstraction breaks down.

value: Show HN: Expectllm – "expect"-style pattern matching for LLM conversations

author: entropyvector


value: ehaveman

value: Recently I was experimenting with some basic generative art pieces across a variety of similar algorithms and I found myself constantly tweaking parameters and re-running the algorithm to see the results - so I built a framework/harness for them where I can tweak the parameters via a bank of sliders. Squiggles and Segments are my favourites so far but I hope to add more.

value: Show HN: Generative Art Synthesizer

author: ehaveman

title: Show HN: Generative Art Synthesizer


value: sankalpnarula

value:
I built a GitHub Action that lets you deploy Docker stacks to a Portainer instance sitting behind a private network — without opening any ports to the internet.
The action spins up an ephemeral Tailscale node during the CI run using OAuth (so it never needs a long-lived auth key), reaches your Portainer API over the tailnet, deploys or updates your stack, then immediately logs the node out on cleanup — even if the job fails.
The problem I was trying to solve: I run Portainer on a home server and didn't want to expose port 9443 publicly or set up a reverse proxy just to enable CD from GitHub Actions. Tailscale already handled my VPN — I just needed the CI runner to join the tailnet temporarily.
It supports stack create/update/delete, private registry auth (GHCR, Docker Hub, etc.), env var injection, MagicDNS hostnames, and auto-detects your Portainer endpoint if you only have one.
Marketplace: https://github.com/marketplace/actions/portainer-tailscale-d...
Happy to answer questions — feedback welcome, especially if you use Portainer + Tailscale differently.

value: Show HN: GitHub Action to deploy to Portainer over Tailscale (no open ports)

author: sankalpnarula


value: jackedney

value:
Prothon is a Python project generator that scaffolds a uv-based project with eight quality tools (ruff, ty, pytest, hypothesis, mutmut, bandit, vulture, complexipy) and a documentation-driven workflow for AI coding agents.
The problem it solves: AI assistants lose context between sessions and drift from your decisions as context windows fill up. Prothon addresses this with three ideas:
1. A three-level doc hierarchy (SPEC, DESIGN, PATTERNS) where each level scopes a single concern and higher always overrides lower. The AI implements from these docs, not from memory. Each doc-writing step is a dedicated agent that refuses content belonging at another level.
2. Automated agents that keep things consistent: one cross-checks the three docs for contradictions, one generates reference skills from live documentation for your stack, one verifies code implements what the docs describe.
3. A "promise" system for execution. Before each task, the agent declares what files it will touch, success criteria, and expected line counts. The promise is verified against the actual git diff. This makes context drift measurable rather than something you notice after the fact.
CLI:
```
prothon new          # scaffold from template
prothon init         # add to existing project
prothon spec         # requirements Q&A
prothon design       # architecture Q&A
prothon patterns     # conventions Q&A
prothon execute      # plan, promise, build
prothon compliance   # verify code vs docs
```
Built on copier, so existing projects can pull upstream template improvements. Currently targets Claude Code, designed to be agent-agnostic.
https://prothon.dev
https://github.com/jackedney/prothon

value: Show HN: Prothon – docs-first Python project generator for AI development

author: jackedney


value: slewisbennett

value:
Problem: This was truly a "solve your own problems" situation. As a Product Manager, you are buried in meetings. Meetings with customers, prospects, vendors, stakeholders, the list goes on. You are also actively looking for market opportunities to innovate and drive that solution through funding, building, delivering, marketing, selling, adopting, and maintaining it. All of that requires two major capabilities: the ability to retain and recall everything you learn and do with the product at a moment's notice, and the ability to generate all of the documentation that supports the product lifecycle so you can deliver value. This problem gets amplified in smaller companies, where it just doesn't make sense to have a team of Product Managers, Product Owners, BAs; you have one Product Manager doing it all.
Solution: ForceVue is an AI-powered product strategy workspace that turns real inputs (research, interviews, competitive analysis, goals) into production-ready docs (PRDs, business cases, epics, etc.), with every AI suggestion traceable back to the evidence and outcomes that drove it.
Why it matters: No more worrying about "when am I going to have time to do real work?" Everything you need to define your product strategy, deliver value, and get customers to use it is at your fingertips. ForceVue is your product brain, collecting all your product learnings. It handles the grunt work of storage, recall, and product management documentation for you. The real work becomes those crucial conversations, learning about pain points you can solve and opportunities where a solution can make someone's life easier.

value: Show HN: ForceVue

author: slewisbennett

title: Show HN: ForceVue


value: tarekclarke

value: Show HN: Resilient RAP: A self-healing data pipeline with <20ms BERT inference

author: tarekclarke


value: cpendery

value: I built this small library to easily run an Ink app as an SSH app. I was inspired by Wish / all the work of the Charm team on the golang TUI ecosystem and wanted some similar tools for Node/JS

value: Show HN: Inkish – build SSH apps with React

author: cpendery


value: suhteevah

value: Show HN: LogSentry – Static analysis for logging quality (100% local)

author: suhteevah


value: Show HN: IssuePay Browser Extension – Calculate your Score for any Job Offer


value: marksantonocito

value:
Hey HN, I'm Marco, a musician and developer. I built Coco because every ear training app I tried felt like a random quiz generator with no actual pedagogy behind it.
*What it is:* A mobile app (iOS/Android) with structured courses for ear training (intervals, chords, scales, relative pitch, and pitch recognition). Sessions are 2–5 minutes. Levels unlock sequentially, each one designed with a specific learning goal.
*How I got here:* I spent a long time going through the research literature on pitch perception and aural skill acquisition (Levitin, Zatorre, Deutsch, and others). A few findings shaped the whole design:
1. Isolated interval drills barely transfer to real musical listening. Tonal context matters.
2. You learn faster when you start with maximally contrasting sounds and gradually introduce similar ones ("contrast before similarity").
3. Short daily sessions with spaced repetition outperform long sporadic ones.
4. Most people conflate ear training with perfect pitch. Relative pitch (understanding how notes relate in context) is the actually useful skill.
No existing app I found followed these principles in a structured way. Most just randomize exercises from a flat pool with no progression logic. So I built one.
*What's different pedagogically:* Every course follows a deliberate arc. For example, in melodic intervals you don't start with all 12 intervals at once; you start with a perfect 5th vs. minor 2nd (maximally different), build up contrast pairs, then progressively add intervals that are closer in size. Each practice level is preceded by a short theory intro so you know what you're listening for and why.
*Current state:* Just launched. Six courses live (Perfect Pitch, Relative Pitch, Melodic Intervals, Harmonic Intervals, Chords, Scales). It's still early and I'm actively iterating. Would love feedback from anyone here who plays music or has thought about how skill acquisition works in audio/perceptual domains.
Happy to answer questions about the pedagogical design, the technical architecture, or the research that informed it.

value: Show HN: Coco Ear Training – a research-backed ear training app for musicians

author: marksantonocito


value:
This is my first project that I have built that can be used by people other than me!
I was trying to get schbench to work on RedoxOS, but unfortunately it uses many linux specific features (eg futex), so I thought why not keep it in line with Redox and write it in Rust!!
Would really like some feadback from experienced devs here on what I did good and what could have been improved!

value: Show HN: Schedrs – a minimal and simple scheduler benchmark written in Rust


value: longas

value: If you're like me and you've tried every note-taking app out there, but always end up back on Apple Notes, you might find this useful.

value: Show HN: Apple Notes CLI for Agents

author: longas

title: Show HN: Apple Notes CLI for Agents


value: bturtel

value:
Hey HN! I RL-tuned an open-source LLM (gpt-oss-120b — 120B MoE, but only 5.1B active params) to predict "What will Trump do?" in any situation, trained on nothing but public news collected automatically from search queries.
The trained model beats GPT-5, and both dataset and trained model are open sourced.
Data generation: Generated 2,108 binary forecasting questions from just a search query and a date range using the Lightning Rod SDK (https://github.com/lightning-rod-labs/lightningrod-python-sd...). Questions are generated from historic news articles — like "Will Trump impose 25% tariffs on Mexico by March 1?" — and resolved by checking what actually happened after the deadline. No human annotation — the whole pipeline is automated.
Training: GRPO with Brier score as the reward signal. LoRA rank 32, 50 training steps.
Results: Slight accuracy edge over GPT-5 (Brier 0.194 vs 0.200), but big gains in calibration — the RL-tuned model produces much better probabilities (ECE 0.079 vs 0.091).
Dataset: https://huggingface.co/datasets/LightningRodLabs/WWTD-2025
This is a fully automated way to spin up domain expert LLMs from public web data with just a few search queries, no labeling/annotation required.
I’d love any feedback, or suggestions for what domain expert to train next!

value: Show HN: Trained an LLM to predict "What will Trump do?"

author: bturtel


value: bagusfarisa

value: Sign up to get free credits

value: Show HN: Turn Figma Design into Detailed User Story

author: bagusfarisa

story_text: Sign up to get free credits


value: ChadNauseam

value:
I'm trying to scroll social media less, but I keep being afraid of "missing the news". There's no traditional alternative, because while I read some magazines, most of my interests are too niche to have a dedicated magazine I can read regularly.
In the past I've used RSS to make a custom feed. But as a supplement to that, I made this site, which allows you to enter a few interests and then does a daily LLM call with web search to gather news about those interests. Then it emails you what it finds. It does a surprisingly good job of surfacing stuff I'd never have heard of otherwise.
I've been enjoying reading the emails and thought I'd share it. (I'm not planning on monetizing this but I may have to disable signups if it starts costing me too much money)

value: Show HN: Personalized Newsletters

author: ChadNauseam

title: Show HN: Personalized Newsletters


value: ftchd

value: Show HN: Rclone UI

author: ftchd

title: Show HN: Rclone UI


value:
I built tuber to get information from YouTube up to 100x faster.
Two core features:
- If a video title is a question, tuber gives a direct answer first.
- Then it generates a timestamped summary with Claude, so you can jump to the exact parts that matter.
Example:
- Video Title: "Did People Used To Look Older?"
- Tuber comment at the bottom: "People in old photos genuinely appear older than their current-day equivalents — but this "retrospective aging" effect is both real and illusory."
Enjoy tuber!

value: Show HN: Tuber – YouTube client for productive watching


value:
Live: https://subconscious-scheduler.vercel.app/dashboard/tasks
Repo: https://github.com/ostepan8/subconscious-scheduler
I built this because I wanted a daily briefing on my sports teams and stocks without checking five different apps. You pick your topics, set a schedule, and an agent researches and writes the email for you.
Stack: Convex for backend/scheduling, Resend for email delivery, Claude for agent logic.
Setup takes ~30 seconds through the UI, or describe what you want to the chat agent and it configures itself. Self-hostable, but bring your own API keys (live is completely free).

value: Show HN: Subconscious open source AI agents that send you personalized emails


value: isitcontent

value: Show HN: Celeste game installs as ELF binary (42kB) on ESP32/breezybox [video]

author: isitcontent


value: teilee

value: Show HN: Claude Code Web – Run Claude Code Agent as an HTTP Endpoint

author: teilee


value: xecaz

value: I bought a WCH BLE Analyzer PRO, only to realize it doesn't have Linux support. Using the windows binaries, i reverse engineered their USB implementation, and vibe-coded a capture tool together in less than 24 hours.

value: Show HN: I made a Linux driver for WCH BLE Analyzer PRO

author: xecaz


value: ElMuncho

value:
I built Urich after getting tired of hand-wiring DDD/CQRS on top of Starlette: routers, command handlers, OpenAPI, and DI scattered everywhere.
The idea: one object per bounded context. You define a DomainModule (aggregate, repository, commands, queries, event handlers), call app.register(orders_module), and get routes like POST /orders/commands/create_order and GET /orders/queries/get_order plus OpenAPI from your dataclasses. Event bus, discovery, and RPC are separate modules; you plug in your adapters (Redis, Consul, etc.) or use in-memory defaults. Core stays small and protocol-based so you’re not locked in.
Python 3.12+, Starlette, Pydantic. CLI for scaffolding (urich create-app, add-context, add-aggregate). Docs and an ecommerce example are in the repo.
Would love feedback from anyone building microservices with DDD/CQRS — what’s missing, what would break in your setup, or what you’d want next (e.g. more adapters, patterns).

value: Show HN: Urich – Async DDD framework for microservices on Starlette

author: ElMuncho


value: fdefitte

value:
Hey HN, I built Cobalt, an open-source testing framework for AI agents and LLM apps.
Most eval tools (Braintrust, Arize, LangSmith) want you to live in their UI. Dashboards, manual reviews, clicking through results. That's fine for exploration, but it doesn't catch regressions. We needed something that runs in CI like any other test suite, lives in code, and fails the build when quality drops.

  npm install @basalt-ai/cobalt
  npx cobalt init
  npx cobalt run

Write experiments as code:

  import { experiment, Dataset, Evaluator } from '@basalt-ai/cobalt'

  const dataset = Dataset.fromLangfuse('support-tickets')

  experiment('support-agent', dataset, async ({ item }) => {
    const result = await myAgent(item.input)
    return { output: result }
  }, {
    evaluators: [
      new Evaluator({ name: 'Helpful', type: 'llm-judge', prompt: 'Is this response helpful and accurate? {{output}}' }),
      new Evaluator({ name: 'No hallucination', type: 'llm-judge', prompt: 'Does this contain fabricated info? {{output}}' }),
    ]
  })

`npx cobalt run --ci` exits with code 1 if thresholds are violated. The GitHub Action posts score tables on PRs and auto-compares against base branch.
The part I'm most excited about: Cobalt ships with a built-in MCP server, so you can drive it entirely from Claude Code. Just tell it "compare GPT 5.2 with 5.1 on my support agent" or "run my experiments, find the failing cases, and fix the prompt." It runs the experiments, diffs the results, and iterates on your code without you leaving the terminal. Turns eval from a chore into a conversation.
Pull datasets from Langfuse, LangSmith, Braintrust, or plain JSON/JSONL/CSV. Results stored locally in SQLite. No accounts, no dashboards, no vendor lock-in.

value: Show HN: Cobalt – Unit tests for AI agents, like Jest but for LLMs

author: fdefitte


value: jomamax

value: Show HN: HelixDB Explorer – A macOS GUI for HelixDB

author: jomamax


value: humanji

value:
I built Ledgr because I was tired of giving Plaid access to my bank account and paying $99/year for the privilege.
It’s a desktop app for macOS (Apple Silicon only for now). You import Chase CSV files, everything goes into local SQLite, and transactions get categorized automatically. There are 50+ built-in rules, learned rules that improve as you correct them, and an optional local LLM via llama.cpp. You bring your own GGUF model. No API calls, no cloud, no telemetry.
Stack: Tauri 2.0 (Rust + React), SQLite, llama.cpp bindings. One thing I haven’t seen in other tools: every transaction shows why it was categorized (rule name, confidence score, or “manual”). You can set budgets, filter/search, and export to CSV.
Free and MIT licensed. Limited right now: only Chase CSV, only macOS. I wanted to ship and see if anyone else cares about this approach.
GitHub: https://github.com/Humanji7/ledgr
Download (macOS ARM): https://github.com/Humanji7/ledgr/releases/latest

value: Show HN: Ledgr – Offline finance tracker with local LLM categorization

author: humanji


value: gregorydickson

value:
This is a port of the Pickle Rick Gemini CLI extension (itself an implementation of Geoffrey Huntley's "Ralph Wiggum" technique) for Claude Code, with one meaningful enhancement: context clearing
  between iterations.

  The core idea: a Claude Code Stop hook intercepts every session exit and blocks it, injecting a fresh prompt instead. Claude never actually stops — it just keeps working through a rigid lifecycle (PRD
   → ticket breakdown → per-ticket research/plan/implement/refactor) until the task is genuinely complete or a limit is hit.

  The problem with long loops: Claude Code compresses old conversation turns as context fills up. After enough iterations, the agent loses track of what phase it's in, which tickets are done, and what
  it was supposed to be building. It starts restarting from scratch.

  The fix: every decision: block response from the Stop hook includes a reason field with a structured session summary — current phase, iteration count, ticket checklist with status, original task,
  session path. Claude Code injects this as a system message at the top of each new iteration. Even after full conversation compression, Rick wakes up knowing exactly where he is.

  Workers (Morty) already got clean context for free since they're fresh claude -p subprocesses. This brings the same resilience to the long-running manager session.

  Also ports the "Pickle Jar" queue — you can jar multiple tasks during the day and run them all unattended overnight with /pickle-jar-open.

  Repo: https://github.com/gregorydickson/pickle-rick-claude

  Credit: galz10 for the original Pickle Rick extension, Geoffrey Huntley for the Ralph Wiggum technique.

value: Show HN: Pickle Rick Ported to Claude Code – Like a Ralph Loop

author: gregorydickson


value: yevbar

value:
*for some cases
Using cloud sandboxes to run them in I tested:
- A single coding agent just told to make a better parser
- An agent told to write a better parser within the constraints of tests/benchmarks
- An agent swarm that self-improved the premise with extra tests/benchmarks in order to more "truly" write a better parser
The results were a success! I was able to end up with both performance (up to 3.07× faster) and memory (up to 5.75× less) in locally runnable benchmarks.

value: Show HN: I vibed a better OCaml parser than Jane Street in 69 steps

author: yevbar


value:
In 2018, I attended Start Up school with the intention of creating a health tech start up. It started as an EHR but in an overly crowded space and dwindling desire for “social media” platform, I trashed the idea and started something new - a basic way for people to understand their health; distilling a complex topic into something more simple and understandable.
I’ve finally picked up enough technical skills (and with some coding help from AI) and data/business understanding to bring out Preact Health. Would love some feedback - I know there’s bugs and glitches: it’s a Shiny front end with a Python API and Postgres database. I’n confident with the data and the math - the technical side of software development is the weakness but I think it’s in a workable enough fashion to release.
Feel free to use without creating an account to see what it’s like and if you feel the desire to save it off and return later (future updates will include single question updates to get an updated score based off changes in your health/lifestyle) to see your score.
There is a path to sustainability where the road map currently includes incentivizing people to provide data and be paid for it, to help build risk models for insurance based off actual user data to get past biased population models which overrun insurance at the moment.
Thanks for your attention and if you’d like to give feedback, comment or you can email me at erik@preacthealth.com. Best of luck to all the other founders out there!
Oh and if you’d like to play with the actual algorithm, the Python is open source for collaboration and development:
https://github.com/preacterik/preact-health-scoring
Learn more at the main page:
https://preacthealth.com

value: Show HN: Preact Health

title: Show HN: Preact Health


value:
I run a book club where the club members read 60 books a year (https://www.sixtybooksayear.com/). When reading at a pace of ~5 books/month, there are skills you develop to increase your storage of concepts from any given book, but also your ability to synthesize ideas across books.
I've compiled some of my best working knowledge into this app on how to become a serious reader. Bram's Reading App will help you: (1) set questions you want answered before you even pick up a book [Questions Over Completion], (2) answer those questions as you read with deliberate annotations [Commonbase], and (3) learn to read and manage multiple books at the same time [Discursive Reading].
Other Features include: Widgets and Control Center Shortcuts, Save from Share Sheet, Configurable Per Book Reading Notifications, Vector Embedded Annotations Across Books, Reading Sessions with Live Timers, A Tactile Progress Wheel, Nested Commentary, Full Text Search, Quiz Mode (next release), Micro Essay Builder (future release)
I hope you enjoy, and let me know if you have any great tips about being well read!

value: Show HN: A Question and Annotation Driven Parallel Reading App


value: zbiggistardust

value:
Hey HN!
I've been a digital nomad for the past 4 years. Throughout all that time, I've been either using local SIM cards or, at a later stage, popular eSIM providers.
I've spent a lot of money on these eSIMs.
I've decided to build my own eSIM company. I don't have an office, no employees, no expensive marketing, and thanks to that, I can offer data eSIMs for much lower prices than the competition.
I've poured my heart into the UX and UI of the web, iOS, and Android apps.
I think my apps are much better than what you're using right now
Web is available now, and mobile apps are in review.
Have a try and let me know what you think! Compare prices with other providers yourself!

value: Show HN: Travel Data ESIMs from a Solo Hacker

author: zbiggistardust


value: beeneeb

value:
Most todo apps want your email. I wanted something you could use in 10 seconds and share publicly.
Create a list, get a URL like publictodo.com/yourname, save a one-time key in your password manager. No account, no email, no OAuth.
Built with vanilla JS and Supabase. I see people using this for public project roadmaps, AI agent task lists, or personal accountability. Knowing a list is public has a way of making you actually finish things.

value: Show HN: Public todo lists – no accounts, just a secret key you save once

author: beeneeb


value: oneinx

value:
Manifest-InX EBS is a spec + offline verifier + proof kit for tamper-evident evidence bundles.
Non-negotiable alignment:
- Live provider calls are nondeterministic.
- Determinism begins at CAPTURE (pinned artifacts).
- Replay is deterministic offline.
- Drift/tamper is deterministically rejected.
Try it in typically ~10 minutes (no signup):
1) Run the verifier against the included golden bundle → PASS
2) Tamper an artifact without updating hashes → deterministic drift/tamper rejection
Repo: https://github.com/OneInX/Manifest-InX-EBS
Skeptic check: docs/ebs/PROOF_KIT/10_MINUTE_SKEPTIC_CHECK.md
Exit codes: 0=OK, 2=DRIFT/TAMPER, 1=INVALID/ERROR
Boundaries:
- This repo ships verifier/spec/proof kit only. The Evidence Gateway (capture/emission runtime) is intentionally not included.
- This is not a “model correctness / no hallucinations” claim—this is evidence integrity + deterministic replay/verification from pinned artifacts.
Looking for feedback:
- Does the exit-code model map cleanly to CI gate usage?
- Any spec/report format rough edges that block adoption?

value: Show HN: Manifestinx-verify – offline verifier for evidence bundles (drift)

author: oneinx


value:
Hey HN,
steipete mentioned in an interview that if you can't use a terminal you shouldn't use OpenClaw (paraphrasing). I disagree - the way we interact with the internet is changing, and simply because a new technology carries risk doesn't mean that one cadre of society is uniquely well-equipped to understand and accept the risks.
So, I put my money where my mouth is and built LobsterHelper.
Each instance runs in its own Firecracker micro-VM with LUKS-encrypted storage. Not Docker containers on shared infra. The VMs have no public IP - all access goes through an authenticated proxy.
I can't make the AI safe yet, but I can make the infra safe, and that's a good place to start.
We've got a long dev-log lined up (3rd party api configuration on platform, token metering, free token use tiers, openclaw UI enhancements) and we'll have bonuses for early adopters along the way.
We're on a long journey to make these technologies safer and more accessible, and we'd hope you join us for the ride.
Alex

value: Show HN: LobsterHelper – Managed OpenClaw on Firecracker VMs


value:
Hello all,
I wrote a tool to optimize SQL queries using LLM models. I sometimes struggle to find the root cause for the slow running queries and sending to LLM most of the time doesn't have good result. I think the reason is LLM doesnt have the context of our database, schemas, explain results .etc.
That is why I decided to write a tool that gathers all infor about our data and suggest meaningful improvements including adding indexes, materialized views, or simply rewriting the query itself. The tool supports only PostgreSQL and MySQL for now , but you can easily fork and add your own desired database.
You just need to add your LLM api key and database credentials. It is an open source tool so I highly appreciate the review and contribution if you would like.
Feel free to check it out : https://github.com/SubhanHakverdiyev/OptimizeQL

value: Show HN: SQL Query Optimizer

title: Show HN: SQL Query Optimizer


value: avsavani

value: I spent a month to put together a workout app without writing a single line of code by hand. It's on par with many apps like Fitbod or Fitness AI. Got approved on iOS App Store. Let me know if you want free access, only thing I ask is to give me genuine feedback and one feature you would like to see. I will be asking Codex/Claude to rank the top features and implement it.

value: Show HN: Vibe coded iOS workout app with Apple Watch support

author: avsavani


value: TobeyStar

value: Show HN: Locational Variable Theory – An informational framework for physics

author: TobeyStar


value: skicoachapp

value:
I’m a solo developer based in Austria and over the past year I built a ski technique analysis app that runs fully offline on the phone.
No cloud processing.
No account system.
No subscription model.
I originally built it because I was frustrated with two things:
 1. seasonal sports apps charging year-round subscriptions
 2. performance data being tied to cloud accounts for no strong technical reason
Instead of debating the model, I decided to try building something different.
⸻
The technical approach
The app processes:
 • GPS
 • motion sensors
 • acceleration data
All analysis happens on-device.
The biggest challenges weren’t UI. They were:
 • sensor noise during aggressive turns
 • battery drain during long ski days
 • balancing sampling rate vs. usable signal
 • designing a scoring model that feels intuitive but is still technically grounded
The offline requirement made architecture simpler in some ways and harder in others.
No backend meant:
 • no server costs
 • no sync logic
 • no auth system
 • no cloud ML pipeline
But it also meant:
 • everything must run within phone constraints
 • optimization matters
 • no ability to “fix it in the cloud”
⸻
What didn’t work
 • I overestimated how much people care about privacy as a primary selling point.
 • Distribution is significantly harder than engineering.
 • Launch posts don’t move the needle nearly as much as you think.
The app currently has 600+ downloads across iOS and Android. No investors. No paid marketing.
Getting the first 100 users was easier than getting from 300 to 600.
⸻
The business decision
I chose one-time pricing instead of subscription.
From a pure revenue perspective, subscription would likely generate more predictable income.
But I wanted to see whether a niche sports product could survive without recurring revenue and without cloud dependency.
It may turn out that this was financially naive. I genuinely don’t know yet.
⸻
What I’m struggling with now
 • distribution without hype cycles
 • explaining “offline” in a way that isn’t marketing-sounding
 • deciding whether staying small and sustainable is enough
I’m curious how other builders think about:
 • offline-first architectures in 2026
 • one-time pricing viability
 • building for niche seasonal markets
Happy to answer technical questions.

value: Show HN: An offline-first ski analysis app

author: skicoachapp


value: steveruizok

value: Anonymous multiplayer drawing app (with all that entails) in a canvas that slowly scrolls everything off-screen. I made this back in 2023 but just got it hosted again, still fun! For a private experiences, e.g. with family, you can use /slow/<any-id> and share that with a friend. There's a fast endpoint too.

value: Show HN: Together, multiplayer drawing chat room

author: steveruizok


value:
The core idea is that no single LLM is best at everything, so we built orchestration primitives that let you combine them intelligently via a single API.
Mixture-of-Agents (MoA): Our /blend endpoint implements multi-layer MoA. You send a prompt to 2-6 models in parallel, then each model refines its answer using the other models' outputs as reference material. This runs for 1-3 configurable layers before a synthesizer model produces the final response. We also built a Self-MoA variant: a single model generates 2-8 diverse candidates using temperature variation and distinct agent prompts ("prioritize correctness", "anticipate edge cases", "be skeptical"), then synthesizes the best parts. Six blend strategies total: consensus, council, best_of, chain, moa, and self_moa.
Circuit breakers: Every model has a health tracker with a classic closed to open to half-open state machine. Three consecutive failures trips the circuit for 30 seconds. When a model is down, mesh routing automatically skips it and tries the fallback chain, so no wasted latency on providers that are having a bad day. The SSE stream emits route events so you can see exactly what happened: trying, failed, skipped(circuit_open), trying, success. OpenRouter gets its own tuned thresholds (6 consecutive 429s, 20s cooldown) because rate limits there behave differently than hard failures.
Auto-router: model: "auto" does zero-overhead heuristic routing, pure regex classification, no LLM call. Code goes to GPT, math/creative goes to Claude, translation goes to Gemini Flash, etc. Simple, fast, and surprisingly effective for common queries.
Other things that were fun to build:
- Credit settlement with margin targeting: we reserve credits upfront, then reconcile against actual provider cost after the response completes
- Per-user semantic memory via pgvector: conversations build retrievable context across sessions
- BYOK encryption (Fernet/AES-128) so you can bring your own API keys and skip our billing entirely
The whole backend is async Python (FastAPI + asyncpg + LiteLLM), frontend is static Next.js served by the same FastAPI process in production. Single Docker image on Railway.
For the technically curious: https://llmwise.ai/llms-full.txt has the complete platform documentation in plain text, and there's also a machine-readable view at https://llmwise.ai/ai designed for AI agents to consume.

value: Show HN: LLMWise – Compare, Blend, and Judge LLM Outputs from One API


value: dormstern

value:
It reads Docker Compose, Helm charts, K8s manifests, and Spring Boot configs, extracts every network dependency, and generates per-service NetworkPolicies.
Tested against real production stacks:
Sentry self-hosted (70+ services): 411 dependencies, 71 policies, 11ms
PostHog (25+ services): 23 dependencies, 12 policies, 128ms
Key design decisions:
Static analysis only. No agents, no cluster access, no observation period. Works offline.
AI is optional. Rule-based parsers handle the core. --ai adds Ollama (local) or Gemini (cloud) for edge cases.
Interactive TUI lets you review every dependency before generating YAML.
Per-service output with both ingress AND egress rules.
The thesis: your configs already declare every dependency. Why are we paying for 30-60 day observation periods and runtime agents?
Written in Go, MIT licensed. Would love feedback from anyone running NetworkPolicies in production.

value: Show HN: Segspec (CLI) K8s NetworkPolicies from App Configs (Go)

author: dormstern


value: aschuth

value:
I work as an engineer at the Dutch government. We have hundreds of technical standards that developers should follow when building government software: API design rules, messaging protocols, authentication profiles, accessibility requirements. The problem is that most developers don't know these standards exist until someone reviews their code (if at all).
Skills are Markdown files that inject domain knowledge into AI coding tools. When a developer starts building an API, the tool automatically loads the relevant standard. No plugins to write, no code. Just structured knowledge in Markdown.
I built a marketplace (https://github.com/MinBZK/overheid-claude-plugins) with now 38 skills covering Dutch government standards. Skills are an open standard (https://agentskills.io/) adopted by Claude Code, GitHub Copilot, Cursor, and others.
The interesting part, certainly for a government: you don't have to be a developer to write a skill. A policy officer who knows the standard can structure it in Markdown and suddenly every developer using these tools gets that knowledge for free.

value: Show HN: Skills – Making AI coding tools aware of government standards

author: aschuth


value: mfilion

value: Show HN: Running Debian on the OpenWrt One

author: mfilion


value: badarsebard

value:
Hi HN. I built Nix It because I was tired of switching back and forth between my email client and task tracker and wanted a way to manage both uniformly. It gave me the tool I always wanted, and the process forced me to sharpen the system I use personally.
The core idea behind the system is that elimination is the highest-leverage action in any work system. Before you organize, prioritize, or schedule something, ask whether it should exist at all. My experience has shown me that important things come back naturally.
Nix It is an email client (Outlook available, Gmail planned) combined with a task management canvas. Emails and tasks live side by side as cards on a Kanban-style board. Conceptually, everything flows through three stages: filter what enters, distill what remains by controlling visibility with states and time-based triggers, and eliminate aggressively. The goal is to keep your system as close to empty as possible.
Try the sandbox without signing up: https://sandbox.nixit.app
Main site: https://www.nixit.app
Full methodology: https://www.nixit.app/system
I built it using SvelteKit and Convex. Happy to talk about the build, the philosophy, or why I think most productivity tools make the problem worse.

value: Show HN: Nix It – Eliminate work instead of organizing it

author: badarsebard


value:
Hey everyone,
I wanted to share one of my passion projects that I've been working on for the past year. AetherCam is a video recording app that allows you to apply effects to the audio track in real-time. You can boost volume, add reverb, compressor, eq, and delay. Everything on the fly.
The idea for AetherCam came to me when I was recording myself playing guitar and thought that the part that I came up with would sound really cool if there was some reverb applied to it. Day after that "revelation", I sat down and started coding the app. I had some prior experience with AVFoundation and Core Audio, as I worked in a startup that dealt with audio for a brief moment, so knew what I needed to get the ball rolling, but still, the effects were one of the toughest part to write.
I already have version 1.1 in the works that significantly improves the reverb engine. Would love to know what you think! :)

value: Show HN: AetherCam, a video recorder focusing on audio