value: SimplyLiz

value:
I've been building AI-assisted coding tools for the past year and kept running into the same problem: AI assistants are blind to code structure.
When you ask "what breaks if I change this function?", the AI greps for text patterns, reads random files hoping to find context, and eventually gives up and asks you to provide more context.
CKB gives AI tools the knowledge they're missing. It indexes your codebase and exposes 80+ MCP tools for:
- Impact analysis: blast radius with risk scores before you touch anything
- Dead code detection: confidence-scored candidates based on call graphs + optional telemetry
- Security scanning: 26 patterns for exposed secrets (API keys, tokens, credentials)
- Ownership: CODEOWNERS + git-blame fusion with time decay
- Affected tests: run only what matters instead of the full suite
- Multi-repo federation: query across all your repositories
Works with Claude Code, Cursor, Windsurf, VS Code, and anything that speaks MCP. Also has CLI and HTTP API for CI/CD integration.
Technical details:
- Written in Go
- Uses SCIP indexes for precise symbol resolution
- Incremental indexing (updates in seconds)
- Presets system for token optimization (load 14-81 tools based on task)
- Three-tier caching with auto-invalidation
Install: `npm install -g @tastehub/ckb && ckb init`
Free for personal use and small teams. Source on GitHub.
Would love feedback, especially on the MCP tool design and what's missing for your workflows.

value: Show HN: CKB – Code intelligence for AI assistants (impact, dead code, security)

author: SimplyLiz


value: schappim

value: Show HN: CLI for text-to-speech using OpenAI/Deepgram/Elevenlabs

author: schappim


value: bidwellm

value:
I’m building Newzino (a story-tracking news site). I just added a feature called Voices: a set of fictional, AI-generated pastiches of historical writers/thinkers reacting to the story.
It’s explicitly labeled as fictional (“AI-generated pastiche… not real quotes”). The goal isn’t “fake quotes” — it’s:
- a fast way to get multiple perspectives
- more blunt critique than modern “safe” corporate-speak
- a tool to stress-test the narrative/incentives around a story
Would love feedback on:
- whether this is useful vs. cringe
- obvious ethical/UI pitfalls
- which historical voices you’d actually want (or never want)

value: Show HN: New feature: "Voices" – fictional commentary alongside current news

author: bidwellm


value:
Hey HN,

  I built an open source tool to transcribe Instagram Reels using OpenAI's Whisper model.

  GitHub: https://github.com/stym06/reelstudio

  How it works:
  - Paste a Reel URL → Worker downloads via yt-dlp → Whisper transcribes → Get shareable transcript page

  Tech stack:
  - Next.js 14 frontend
  - Go worker (polls PostgreSQL for jobs)
  - faster-whisper for transcription
  - No login required

  The architecture is simple: the frontend creates a task in PostgreSQL, a Go worker polls for pending tasks, downloads the video, runs Whisper, and saves the transcript. The
  frontend polls until complete and redirects to the transcript page.

  I built this because I wanted to repurpose Reel content into blog posts and needed accurate transcripts with timestamps. Existing tools either required accounts, had watermarks, or
   were expensive.

  Self-hosting is straightforward - just need PostgreSQL, the Next.js server, and the Go worker with Python/Whisper installed.

  Would love feedback on the architecture or any feature suggestions. The worker is designed to be horizontally scalable if anyone wants to add Redis/queue support.

value: Show HN: ReelStudio – open-source Instagram Reel transcription with Whisper


value: smusham

value:
I built Taxplain because existing tax software is great at form-filling but terrible at guidance. Most Americans don't understand why they owe what they owe or how to optimize their situation.
Taxplain uses AI to answer tax questions in plain English across complex scenarios: crypto gains, self-employment, AMT, business structures, state-specific rules. It's like having a tax advisor in your pocket, powered by verified IRS documentation and tax code.
The core insight: people don't want software—they want answers. We're targeting the DIY tax filer market that TurboTax underserves on guidance.
Currently in beta. Would love feedback on the approach, the UX, or whether this solves a real problem for you.
https://www.taxplain.xyz/

value: Show HN: Taxplain – AI Tax Guidance That Explains Your Situation

author: smusham


value: oryxandcake

value:
Hi! I built AES Cypher to help me try lots of password variations when i couldnt remember exactly what the password was.
Instead of manually trying each password, AES Cypher lets you load a text file with your common passwords and automatically tests them. When it finds the right one, it shows you which password worked.
It's not a password cracker. This only works if the correct password is in your list. But if you have a rough idea you can generate variations and try them all.
Features:
- AES-256-CBC encryption with PBKDF2 (100k iterations)
- Dual mode: encrypt or decrypt files
- Batch password testing from a file
- Works with any file type
- Mac native app, works offline
- One-time purchase ($9.99), no subscription
The app is built with Python/Tkinter and uses the Cryptography library.
Target audience is:
1. Non-technical users who need this functionality and dont know how to run scripts in the CLI
2. Technical users who want a quick GUI tool instead of context-switching to terminal
3. People helping less-technical friends/family (easier to send an app than teach them scripting)
Available at: http://aescypher.com/
I'd love to hear what you think.

value: Show HN: AES Cypher – Mac encryption with batch password testing

author: oryxandcake


value: arsentjev

value:
2 weeks ago, I posted chroma-exploter here: https://news.ycombinator.com/item?id=46624731 and it received a lot of positive feedback. So I decided to build a similar tool for Pinecone.
While both being vector databases, Pinecone is more enterprise grade and a lot more functionally rich than Chroma, hence a separate app.
This Mac native app makes it easier to work with Pinecone data, with all types of indexes (dense, sparse and hybird) and supports reranking.

value: Show HN: Pinecone DB Explorer

author: arsentjev

title: Show HN: Pinecone DB Explorer


value:
Founder here. I built NEO, an AI agent designed specifically for AI and ML engineering workflows, after repeatedly hitting the same wall with existing tools: they work for short, linear tasks, but fall apart once workflows become long-running, stateful, and feedback-driven. In real ML work, you don’t just generate code and move on. You explore data, train models, evaluate results, adjust assumptions, rerun experiments, compare metrics, generate artifacts, and iterate; often over hours or days.
Most modern coding agents already go beyond single prompts. They can plan steps, write files, run commands, and react to errors. Where things still break down is when ML workflows become long-running and feedback-heavy. Training jobs, evaluations, retries, metric comparisons, and partial failures are still treated as ephemeral side effects rather than durable state.
Once a workflow spans hours, multiple experiments, or iterative evaluation, you either babysit the agent or restart large parts of the process. Feedback exists, but it is not something the system can reliably resume from.
NEO tries to model ML work the way it actually happens.
It is an AI agent that executes end-to-end ML workflows, not just code generation. Work is broken into explicit execution steps with state, checkpoints, and intermediate results. Feedback from metrics, evaluations, or failures feeds directly into the next step instead of forcing a full restart. You can pause a run, inspect what happened, tweak assumptions, and resume from where it left off.
Here's an example as well for your reference: You might ask NEO to explore a dataset, train a few baseline models, compare their performance, and generate plots and a short report. NEO will load the data, run EDA, train models, evaluate them, notice if something underperforms or fails, adjust, and continue. If training takes an hour and one model crashes at 45 minutes, you do not start over. Neo inspects the failure, fixes it, and resumes.
Docs for the extension: https://docs.heyneo.so/#/vscode
Happy to answer questions about Neo.

value: Show HN: First autonomous ML and AI engineering Agent


value: mrgrj

value:
PrecisionRush is a small free iOS timing game I built solo. Weirdly enough, the idea came from playing with the default iPhone stopwatch and thinking: what if this was an actual game?
I’m not much of a gamer myself (I’ve only played a handful of games), but something about this tiny mechanic got stuck in my head, so I decided to build the version I personally wanted to play.
The premise is simple: you get a target time, you start the timer, and your goal is to stop it as close to the target as possible. If you land within ~20ms it feels almost unreal. It’s a tiny concept, but it turned out to be surprisingly addictive.
I shipped it last week and I’m currently in the “first real users” phase. I’ve only got a handful of ratings so far, but I’ve been genuinely happy just seeing people try it. One unexpected thing: a few users even tapped “Support the developer”, which I honestly didn’t think would happen.
I do this on the side and I’m definitely not a top game designer or UX person - I just like building small things I enjoy and iterating on them. I haven’t done any marketing yet and I’m not trying to sell anything here. I’d just love honest feedback from people who enjoy minimal games or quick skill tests:
- Does it stay fun after a few minutes, or does it get repetitive?
- Is the UI/feedback loop satisfying and clear?
- Anything obvious you’d improve or add?
App Store link: https://apps.apple.com/ro/app/precisionrush/id6755596108
Thanks for reading.

value: Show HN: PrecisionRush: a tiny timing game inspired by the iPhone stopwatch

author: mrgrj


value: donadev

value: Show HN: I built a voice journal app to let me journal more

author: donadev


value:
What would reading look like if it were designed around how people actually learn?
I got tired of all the AI study tools that actually just take the cognitive work of studying or reading away from you, instead of building up your own brain. Reading today is also just not the best experience as you forget so much of what you read.
I built Mimir, (readmimir.com), an interactive immersive reader that let's you upload any book/text, read in immersive reading with TTS, active recall, in-margin notes, ask-ai tutor, and automatically creates spaced repetition notes from your notes and answers.
Mimir is currently free, I would love your feedback!!
(more importantly, we're designing some social features - like sharing your margin notes with friends or followers, allowing "community notes" to posted essays, doing reading groups with friends etc!, and if you have ideas for that, i'd love to hear!!)

value: Show HN: AI Native Reading Companion

title: Show HN: AI Native Reading Companion


value: Show HN: An AI-intern to listen to, transcribe, and summarize your podcasts


value: jshchnz

value:
Hiring sites and jobs pages usually kinda suck so I thought it'd be cool if devs could use Claude Code to sort through potential jobs.
To install the skill:
git clone https://github.com/jshchnz/claude-jobs.git ~/.claude/skills/claude-jobs
Some examples:
what's the highest paying job at sentry?
jobs in san francisco at airbnb
engineering jobs at cloudflare
Right now it only supports a few companies that Claude was able to find publicly accessible job listings for: Airbnb, Anthropic, Cloudflare, Coinbase, Datadog, Discord, Dropbox, Figma, GitLab, Instacart, Linear, Lyft, Netlify, Notion, Sentry, Stripe, Vercel
but it's really easy to add your company if you want to be included in the skill: https://github.com/jshchnz/claude-jobs/blob/main/CONTRIBUTIN...

value: Show HN: Use Claude Code to find engineering jobs

author: jshchnz


value: mskrasnov

value: Version v0.5.0 is now available, it is already working stably, although in terms of functionality and consumption of PC resources, I still have a lot to strive for. FSM shows information about processors, RAM, mounted file systems, some information from DMI, etc.

value: Show HN: Yet another system monitor for Linux

author: mskrasnov


value: debba

value:
Hi HN,
I built debba.sql, a lightweight, cross-platform database manager because I wanted a native, fast tool for quick data edits without the heaviness of Electron-based giants or Java IDEs.
The interesting part? This project started as an experiment in vibe coding.
I utilized an AI agent to handle the entire scaffolding and heavy lifting of the implementation. We went from an empty directory to a working app with SSH tunneling, schema introspection, and data editing in record time. It allowed me to focus purely on the architectural decisions, UX "vibe", and solving my specific pain points.
The Tech Stack:
*   Frontend: React 19 + TypeScript + Tailwind CSS (using Monaco Editor for SQL)
*   Backend: Rust Tauri v2 (for native performance and small binary size)
*   Database Access: SQLx (pure Rust, async driver)
Current Features:
*   Multi-DB Support: PostgreSQL, MySQL/MariaDB, and SQLite.
*   SSH Tunneling: Built-in support for connecting via bastion hosts (supports key/agent/password auth).
*   Native Performance: Fast startup (~10MB binary) and low memory footprint.
*   SQL Editor: Full syntax highlighting and execution.
*   Data Grid: Inline editing, row deletion, and easy "New Row" insertion.
*   Schema Tools: Visual "Create Table" wizard (DataGrip style) and introspection.
*   Export: Native CSV/JSON export.
Why I built it:
I often need to jump into a DB via SSH to run a query, edit a specific cell, or check a schema. I wanted something that opens instantly and feels like a native system utility, not a web browser tab.
Roadmap / Help Wanted:
It's currently in Alpha (v0.1.0). I'm looking for feedback, bug reports, and contributions!
Next on the list:
*   Multiple Query Tabs
*   Visual Query Builder
*   Dark/Light mode toggle
The code is open source. Check it out here: https://github.com/debba/debba.sql
Let me know what you think about the tool or the AI-assisted dev process!

value: Show HN: Debba.sql – A lightweight SQL manager built with Tauri and Rust

author: debba


value: wrogistefan

value:
I’ve released LocalPass — a local‑first, offline password manager with zero cloud, zero telemetry, and zero vendor lock‑in.
100% local storage, 100% open‑source.

value: Show HN: LocalPass offline password manager. Zero cloud. Zero telemetry

author: wrogistefan


value: nsomani

value:
Hi HN, it seemed like there was broad interest in the previous Erdos problem that GPT 5.2 Pro solved: https://news.ycombinator.com/item?id=46664631
I recruited a team of smart undergraduates to construct a dataset of ChatGPT responses to every open Erdos problem and verify the output.
They found:
- 3 problems with new proofs (though in 2 cases, historical partial results were found that could be extended to solve the same problem)
- 4 problems where 5.2 Pro or Deep Research found an exact solution in the prior literature that hadn't been documented
- 3 problems where 5.2 Pro or Deep Research were able to strengthen a prior result in the literature
- 3 problems where typos were identified in the problem statement
The most common failure case is that 5.2 Pro solves the problem as stated, but professional mathematicians understand there's an implicit constraint for the problem. For example, maybe the problem says integers, but they really mean only positive integers.
Happy to answer any questions about the dataset!

value: Show HN: GPT-Erdos – the results of GPT 5.2 Pro on the Erdos problems

author: nsomani


value: awalGarg

value:
Hi folks! I'd like to share a proof of concept for an idea I've thought about for a long time. Think of a new form of spreadsheets where the primary data structure is not a rigid grid but a free-form JSON-like structure (but with first class tables support of course). I'm linking here a demo which uses vi style hotkeys for interaction, although of course the idea is not limited to that mode of interaction.
The addresses end up being JSON paths. The layout is currently rigid because it's just a PoC but ideally you'd have much more control over it, kind of like a canvas.
Expressions can refer to other cells via their JSON based address, even relative to their current address. There is no expressions support in the PoC yet but a table in the example does show a dynamic column. Since you have arbitrarily nested arrays/hashes anyway, you can reserve tables to represent arrays of homogenous records, and some of the columns can be dynamically calculated (or have a default dynamic calculation) based on other columns. The expressions are just JavaScript functions, but they can be anything that works with JSON types.
This is very far from finished. I'm just been trying to share early these days and I think many of you'd find the idea itself interesting.
Why? I think spreadsheets are great but they are underutilized because of their rigidity. They are not suitable for version control, being authoritative data sources, powering APIs etc. I don't know if this is the right direction either. I'd be happy to hear your thoughts!
The code is 100% manually written by me (except for the CSS background which I copied from SO). If there is sufficient interest in collaboration, I'd be happy to put up the source on codeberg.

value: Show HN: JSON spreadsheets with vi bindings (proof of concept)

author: awalGarg


value: robgehring

value: Show HN: Translate any document while preserving original layouts and formatting

author: robgehring


value: wbakst

value: Show HN: Mirascope – The LLM Anti-Framework

author: wbakst


value: mosiddi

value: Agent OS treats LLMs like raw compute and provides OS-level governance.<p>Current frameworks let the LLM "decide" whether to follow safety rules. Agent OS inverts this: the kernel decides, the LLM computes.

value: Show HN: Agent OS – 0% Safety Violations for AI Agents

author: mosiddi


value: lavandar-admin

value:
I built STRATA as a living whitepaper for premium timepieces that display real-time weather data for any location. Each dial renders live conditions (temperature, humidity, wind) with historical overlays.<p>Tech stack: React 18, Supabase, Gemini AI, Stripe subscriptions.
Built entirely in Lovable (AI-powered dev environment). Would love feedback on the UX and the "explain without explaining" content approach.

value: Show HN: Strata AI-powered ops platform

author: lavandar-admin

title: Show HN: Strata AI-powered ops platform


value:
We built OptionIncome to track income-focused option selling strategies
(cash-secured puts, covered calls, wheels, spreads) without spreadsheets.
It connects to brokers and tracks strategy-level PnL, with support
for rolling positions and wheel-style trading, so you can see how your option
selling is actually performing.
We built this because spreadsheets don’t scale and existing trading journal
tools don’t handle complex option strategies well.
Happy to answer questions.

value: Show HN: OptionIncome – auto tracker for option sellers


value: The term "sideloading" has been in common use since at least 2009 on XDA Forums, The earliest reference I've seen is 2007.

value: Show HN: XDA Forum discussion on sideloading (2009)


value: tlop

value: Howdy! I've built a tool for identifying VPNs and other anonymous traffic along with querying AbuseIPDB during threat hunts and security investigations. ipcheq2 takes a minute or so to setup and works much faster than online SaaS (and free!) for this sort of data. This tool was built for Security Operation Centers, but is useful for checking out where your website's traffic is coming from as well. Happy hacking!

value: Show HN: Open-source tool for finding VPNs in your traffic

author: tlop


value: hiddenarchitect

value: The Autonomous Autopoietic World Model Generation Artificoal Intelligence<p>Why Protogen is DifferentMost AI today is a "Black Box"—you put text in, and you get text out, but you don't know why. Protogen is a White-Box system:•Metabolic Heartbeat: The system has an internal "pulse." It processes, cleans, and organizes its own thoughts in the background, even when you aren't interacting with it.•Entropy Gating: It uses Shannon Entropy to protect its "sanity." If you feed it nonsense, it detects the chaos and refuses to let it corrupt its internal logic.Symbolic Evolution: It watches how concepts relate. When a relationship becomes strong enough, it "lifts" that concept into a Symbol, creating a permanent foundation for future reasoning.•Recursive Learning: It doesn't just learn facts; it learns rules. It then looks for patterns within those rules to build increasingly complex understanding.

value: Show HN: Protogen – An Autopoietic Autonomous World Model

author: hiddenarchitect


value: nemath

value: I built a tiny tool to answer one question: “If I put $1,500 in my FSA, what does it really cost me and saves me?”<p>Should more people be using their FSA accounts?

value: Show HN: FSA Savings Calculator (see how much pre-tax saves you)

author: nemath


value: xthe

value: Show HN: I Created a Simple Guide to the Best AI Tools for Absolute Beginners

author: xthe


value: AdelAden

value:
I’ve spent the last year watching agentic workflows break the moment a schema changes or an LLM returns a slightly unexpected format. Traditional "chains" are too brittle for production, so I built Aden to move away from static, hardcoded logic. Aden is an infrastructure layer that uses a "Queen Bee" coding agent to transform your natural language goals into a recursive graph of worker agents. When an agent fails or hits an edge case, the framework doesn't just throw an error; it captures the failure trace, uses the coding agent to refactor the underlying node logic or connection graph, and redeploys the fix in real-time. It’s built to be MCP-native with 100+ connectors and includes "Agentic P&L" guardrails to prevent token-burn from runaway loops. You can try it out by cloning the repo and running the quickstart script to build your first autonomous swarm.
contact@adenhq.com

value: Show HN: Aden A self-healing agent framework that refactors its own logic

author: AdelAden


value: pipeabello

value:
I built Runo after years of inconsistent marathon training. GPS watches tell you your pace AFTER it's too late. So I made a simple metronome that plays a beat at your target cadence (steps per minute).
New in 2.0: Apple Watch haptics (run to the beat without headphones), Strava sync, and social features.
4.7 on App Store, 10k+ runners. Would love feedback from the HN community.

value: Show HN: Runo – A metronome app that helps you hold any running pace

author: pipeabello


value: LuqmaanKhan

value:
I built Pikai after using Cursor and Claude Code heavily in real production systems. These tools work well within a single repository, but once you’re working across multiple repos, microservices, and shared libraries, they start making changes with incomplete assumptions about the rest of the system.
Pikai provides a way to share relevant code and architectural context across repositories so tools like Cursor and Claude Code have a more accurate view of the system they’re modifying. The goal is fewer incorrect edits when changes span services.
This is an early beta shaped by day-to-day production use. I’m looking for developers working in multi-repo or microservice environments who want to try it and give direct feedback.
Happy to answer technical questions about how it works.

value: Show HN: Pikai – Making Cursor/Claude Code work better across multiple repos

author: LuqmaanKhan


value: unbuns

value:
I hate laptop shopping. Need to keep 20 Chrome tabs open, cross-reference specs, check pricing. "Best laptop 2026" lists are commission-optimized, not helpful. They go stale when prices shift.
Built an app that takes "lightweight laptop for coding under $1200" and returns curated picks with fresh pricing and reasoning. Currently laptops and phones.
Design: consumer journey = contraction/expansion of opportunities. Explore → AI curates → shortlist → compare. Each interaction updates recommendations via LLM.
Avoided the chatbot trap. LLMs as foundation, but keep good mobile UX (cards, scrolling, navigation).
Not sure if this beats manual research. Honest feedback wanted. iOS app: https://apps.apple.com/us/app/great-recs/id6756940360

value: Show HN: An app that finds your perfect laptop in seconds (no affiliate agenda)

author: unbuns


value: worksOnMyPC

value:
I'm pleased to announce the 1.0.0 beta release of OneTaskAtATime, a Windows desktop task management application built on a simple philosophy: stop managing lists, start executing tasks. Many productivity apps overwhelm users with poor prioritization, complex hierarchies, and feature bloat. OneTaskAtATime takes a different approach.
The core feature is Focus Mode, which presents you with exactly one task at a time—the most important thing you should be working on right now. No distractions, no decision fatigue, just focused execution.
Claude Code was instrumental in developing this application and testing it rigorously. That said, I'm looking for a few testers to try out this app and provide feedback. Let me know if you would be interested!
GitHub Page: https://github.com/cmdavis25/OneTaskAtATime
Beta Release : https://github.com/cmdavis25/OneTaskAtATime/releases/tag/v1....

value: Show HN: OneTaskAtATime – a focused todo list app made with Claude Code

author: worksOnMyPC


value: hiddenarchitect

value: After developing the Protogen engine, I realized that intelligence shouldn't just be individual—it should be collective. I’ve built the Agent Forge V5.0, an orchestrator that births a swarm of autonomous engines (Theoretical Physics, Ethics, Marine Biology, etc.) and lets them 'swarm' the same data simultaneously.Key Features:•Collaborative Swarm Ingestion: Multiple agents interpret the same document through different axiomatic lenses at once.•Emergent Global Consensus: A 'Global Logic Map' that only accepts patterns validated by multiple independent agents.•Hardware-Aware: Automatically scales the swarm based on your CPU/RAM and AMD GPU (via DirectML).•Zero LLM Dependency: This is pure, self-derived logic and autopoiesis.I’m interested in the community's thoughts on Sympoiesis (making-together) and how consensus-based logic maps could provide a more stable foundation for AGI than current black-box models.

value: Show HN: An autopoietic agent forge for emergent, consensus-based AI ecosystems


value: incendies

value:
I built a small free tool that converts images into structured JSON output.
The idea is simple: upload an image, and the tool tries to extract its visual/content information into a clean JSON format that can be used for further processing, automation, or AI workflows.
This started as a side project to speed up my own experiments with image analysis and prompt pipelines. There’s no login, no paywall, and it runs entirely in the browser.
I’m sharing it here mainly to get feedback:
Does the output structure make sense?
What use cases would you expect from something like this?
Anything obviously missing or confusing?
Happy to improve it based on suggestions.

value: Show HN: Free image-to-JSON converter (extract structured data from images)

author: incendies


value: ashiban

value:
I’ve always wanted a way to use Python’s `networkx` from other languages for years, but crossing languages/runtimes was too brittle and the editing/debugging experience were non-existent. The dream was like having fSharp alongside C#, or in GraalVM world having languages interop without significant overhead.
I wanted to explore what a minimal, pleasant developer experience could look like crossing ecosystems, and for portability WASM felt like a good intermediary but until Components there was straightforward way to handle cross-execution state.
I also wanted to see if Claude Code + Opus 4.5 can build something non-trivial (not another React app) that hadn’t really been done before
Umo is what came out - I recorded a short video that's on github.
It only bridges Python modules to Node, gets the libs, extracts types / docs, create wasm components and builds the typescript interfaces/bindings.
Had fun seeing this happen, sharing with folks to see

value: Show HN: Compile Python libraries for TypeScript with type completion (umo)

author: ashiban


value:
Seedance 2.0 Pro is an advanced AI video generation platform that turns text, images, or audio into cinematic, high-fidelity videos.
Built for creators, marketers, and filmmakers, it offers stable character identity, synchronized audio-visual output, and controllable camera motion.
With fast rendering, multiple aspect ratios, and high-resolution support, it enables rapid production of storytelling content, ads, and social media videos without traditional filming complexity.

value: Show HN: Seedance 2.0 Pro AI Video Generator


value: throwawaste

value: Show HN: Infinijest, Video Feed Experiment

author: throwawaste


value: hardbyte

value:
I built an Obsidian plugin that connects to Claude Code, Gemini CLI, or Codex - whatever you have installed. No API keys to configure in the plugin; it just delegates to the CLI tools you already use.
The LLM gets full access to your vault - it can read notes, create files, search. Ask "what did I write about X last month" and it finds and reads the files.
Uses ACP (Agent Client Protocol) for structured data passing and persistent connections.

value: Show HN: Obsidian plugin that uses your existing LLM CLI tools

author: hardbyte


value: Show HN: Sentinel – Audit-Ready JSON DBMS in Rust


value: tmarois

value: Show HN: Atlas – AI Agents for Laravel

author: tmarois

title: Show HN: Atlas – AI Agents for Laravel


value: youngbum

value:
Hey HN, I built Bingsan as an open-source Apache Iceberg REST Catalog.
Why? Existing options (Nessie, Polaris) are Java-based. I wanted something
lightweight that runs alongside PostgreSQL without a JVM.
Stack:
- Go + Fiber framework
- PostgreSQL with pgx/v5 connection pooling
- Prometheus metrics built-in
Performance (Xeon 8581C):
- ~24k req/s throughput
- 44μs p50 latency
- Linear scaling to 200+ concurrent connections
Multi-node:
- Run multiple instances behind a load balancer
- PostgreSQL advisory locks for leader election
- Background tasks coordinate automatically
Quick start:

  docker run -p 8181:8181 ghcr.io/teampaprika/bingsan:latest

Works with Spark, Trino, PyIceberg. Supports S3/GCS, OAuth2, API keys,
multi-table transactions, server-side scan planning.
GitHub: https://github.com/teamPaprika/bingsan
Docs: https://teampaprika.github.io/bingsan/en/
Happy to answer questions!

value: Show HN: Bingsan – Apache Iceberg REST Catalog in Go (24k rps, multi-node)

author: youngbum


value: brendanfinan

value: Projects including Soka will implement the Golden Rule and be licensed under the GPL.

value: Show HN: Soka – The Golden Rule Licensed Under the GNU General Public License

author: brendanfinan


value: tabakd

value:
Hi HN!
We just launched our drum machine vst this month! We will be updating it with many new synthesis models and unique features.
Check it out, join our discord and show us what you made!

value: Show HN: Drum machine VST made with React/C++

author: tabakd


value:
I built an open-source GitHub Action that translates i18n files using LLMs, designed as a drop-in replacement for Lokalise, Phrase, and Crowdin.
The problem: TMS platforms charge per-word and per-seat, and their machine translation lacks product context. A typical SaaS with 500 strings across 9 languages costs $200-500/month.
How it works:
- Extracts strings from your codebase (XLIFF, JSON, PO, YAML)
- Diffs against previous translations (only translates what changed)
- Sends to any LLM (Claude, GPT-4, Gemini, Ollama) with your product context, glossary, and style guide
- Commits translations back to your branch
Key technical bits:
- Structured generation for ICU message format (CLDR plural rules handled correctly - Russian 4-form, Arabic 6-form, etc.)
- Hash-based caching to avoid re-translating unchanged strings
- Provider-agnostic interface - swap LLMs without config changes
GitHub: https://github.com/webdecoy/ai-i18n
Happy to answer questions about the ICU handling, prompt design, or anything else.

value: Show HN: An Internationalization GitHub Action to Replace Crowdin with LLMs


value: ashtadmir

value:
I've been playing around with the new official GitHub Copilot SDK and realized it's a goldmine for building programmatic bridges to their models.
I built this server in Go to act as a OpenAI-compatible proxy. It essentially lets you treat your GitHub Copilot subscription as a standard OpenAI backend for any tool that supports it. I have tested it against OpenWebUI and Langchain.
Key Highlights:
- Official SDK: Built using the new Github Copilot SDK. It’s much more robust than the reverse-engineered solutions floating around and does not use unpublished APIs.
- Tool Calling Support: It maps OpenAI function definitions to Copilot's agentic tools. You can use your own tools/functions through the Copilot without copilot needing access to the said tools just the definitions is enough.
The goal was to create a reliable "bridge" so I can use my subscription models in my preferred interfaces.

value: Show HN: An OpenAI API compatible server that uses GitHub Copilot SDK for LLMs

author: ashtadmir


value: jomadu

value:
Managing cursor/q/copilot rules and prompts across projects is painful. ARM solves this with:
- Semantic versioning for AI rules/prompts
- Install from Git repos (awesome-cursorrules works out of the box)
- Priority-based layering (team standards > community rules)
- Write once, compile to Cursor/Copilot/Amazon Q
- Manifest + lock files for reproducible environments<p>Built in Go, GNU GPL v2 licensed. Would love feedback from the community.

value: Show HN: ARM – NPM for AI coding assistant resources

author: jomadu


value: loganye

value:
Hi HN — we’re shipping a feature in DeepTutor this week: turn a paper into runnable code and export a Jupyter Notebook.
It’s meant for quick reproducibility: implement an equation/method, run a sanity check, and keep everything in a shareable notebook.
Demo: https://www.youtube.com/watch?v=FOnyym-jUPg
Happy to answer questions. What would make this useful in your workflow?

value: Show HN: Paper → Code → Jupyter Notebook (generate and run code while reading)

author: loganye


value: Show HN: Ask your LLM traces what went wrong (vLLora)


value:
I built a tool that adds word-by-word animated captions to videos. All processing happens client-side using the browser - no server uploads.
Tech:
1. Whisper WASM (tiny and small models)
2. Canvas Text
3. MediaBunny to stitch everything together.
The privacy angle was important to me. This processes everything locally and exports directly.
Free, no account, no watermark. Feedback welcome.

value: Show HN: Burn Text – Add animated captions to videos, runs locally in browser


value: almans

value:
I’ve been working on Jiss, a project to make open-source LLMs accessible without the massive cloud bills or the headache of managing your own 24/7 infrastructure.
It’s a distributed network that routes inference requests to a pool of volunteer-run workers. If you have an app already using OpenAI, you can just swap the base_url and start running models like Llama 3 or Qwen3.
The idea:
Instead of relying on big providers, Jiss is powered by people donating idle compute. Whether you’re running Ollama on a Mac, a home server, or a workstation, you can connect your local setup to the network and help serve requests. I built this to see if we could create a useful, shared resource for the open-source AI community.
The highlights:
• Drop-in replacement: Use the standard OpenAI SDK—just change the base URL.
• Streaming: Supports real-time token streaming (SSE).
• Open: Anyone can join as a worker using a single script.
It’s still early so I’d love to get your feedback or have you try running a worker!

value: Show HN: Jiss – A community-powered LLM API I built for open models

author: almans


value: Show HN: Nvidia Nemotron-Personas-Singapore Dataset for Sovereign AI


value: partypete

value:
I created engroles because, as I was looking for a job as a software engineer, I realized that most of the listings out there are black holes where my application likely went to die. However, I noticed that I got an interview with almost every recruiter that reached out to my personal email advertising an actual listing. It taught me that recruiter email outreach almost always represents a real job.
And so I thought to myself, how can I help other job-seeking software engineers get access to an aggregated list of real recruiter outreach? And I came up with engroles. The idea is that as a job seeker, you forward one verified recruiter outreach that you've received to your email in the last 30 days to forward@engroles.com. Once engroles verifies that the recruiter outreach represents a real job listing, it will give you access to apply to any of the listings in the entire job board. Every listing represents a job from another user who has received verified recruiter outreach and sent it to engroles. Each one of the listings in engroles is also linked to a recruiter. When job seekers apply to a job listing, the recruiter is notified, and recruiters will reach out to the job seeker's profile.
This is an initial release. You can see a truncated view of the currently existing job listings without creating an account. Please give me any feedback that you have. Thanks for checking this out!

value: Show HN: Engroles.com – Verified, Active SWE Listings from Recruiters

author: partypete


value:
I built LinkLens because I was paying $80/month for DocSend + Bitly separately.
It tracks:
- Documents: who viewed, which pages, how long
- Links: clicks, location, device, UTM params
Tech stack: Next.js, Supabase, Cloudflare R2
Free tier available. Would love feedback on the product and landing page.

value: Show HN: LinkLens – Document and link tracking in one dashboard


value: bilalba

value:
Standing on the shoulders of OpenStreetMap, three.js, and other open-source projects, I made an open-source, game-like 3D explorer for OSM.
It’s barebones right now (currently loads one scene), renderings need work, and it’s buggy in places. But you can get driving on most roads around the world.
Contributions welcome!

value: Show HN: Walk and drive through OpenStreetMap in 3D

author: bilalba


value: yakkomajuri

value:
I made a little browser extension that makes prices out on the web be hoverable to show how much runway they'll knock off your startup.
In case anyone's feeling frugal: https://github.com/yakkomajuri/runway-nudger

value: Show HN: See how much things cost in terms of your runway

author: yakkomajuri


value: medivhX

value: Clawdbot is great but documentation is scattered. I created this to help people set up local AI OS, especially on Mac Mini, with a searchable error database.

value: Show HN: GetClawdbot – A Community Guide and Skill Hub for Clawdbot

author: medivhX


value: jeyjeyemem

value: Externalized Properties is powerful configuration library which supports resolution of properties from external sources such as files, databases, git repositories, and any custom sources

value: Show HN: Externalized Properties, a modern Java configuration library

author: jeyjeyemem


value: rsc-dev

value: Enhance your DNS security and monitoring with cutting-edge simplicity, adaptability, and real-time insights, safeguarding your domain's performance and integrity.

value: Show HN: DNS Monitor

author: rsc-dev

title: Show HN: DNS Monitor


value: juannyp

value:
Hey!
I am one of the creators of the Clevergoat suite of games. We currently have 7 games and have launched a new game in beta (we call it labs).
It is called TAKES - A Daily Chess Solitaire Game.
Rules:
Capture all pieces on the chess board. If a King is present, it must be the final capture.
There are four difficulty levels, expert mode is unlocked when completing easy, medium and hard. There are three games per difficulty, except expert, there is one.
If you get stuck, you can use a hint. Try and get the best time as you can.

value: Show HN: Takes – A Daily Chess Solitaire Game

author: juannyp


value: louispog

value:
Hey HN, I’m Louis.
I built RustyBoard because I noticed a huge gap in the Rust job market: the jobs exist, but the dedicated boards are empty. Most niche boards list maybe 5–10 new roles a week, yet when I looked at company career pages manually, I found hundreds.
Existing boards seem to rely on manual submissions (which costs money, so volume is low) or generic scraping (which is full of spam). I wanted to see everything available, so I built a system to close that gap.
I wanted to find reliable Rust jobs (SaaS, Cloud, Systems) and how much they were paying, without sifting through hundreds of unreliable listings.
So I built a scraper that targets a curated list of over 600 companies hiring Rust Engineers across 5 of the largest ATS platforms globally (Greenhouse, Lever, Ashby, Workable, TeamTailor), as well as Microsoft's career page. This filters out a lot of the noise and focuses on companies with established hiring pipelines.
Here are some things that I think set it apart -
Strict Source Control: I only scrape verified ATS domains, so the board is full of listings from trusted companies.
The Insights Page: I’m trying to visualize the market rather than just list it. You can see real-time breakdowns of Remote vs. Onsite, top industries, average salary, and tech stacks paired with Rust and much more relevant info.
No accounts required: You can search, filter, and apply without signing up.
It’s early days, so definitely not perfect. The data is currently US-heavy because my initial scrapers focused on US-centric ATS platforms, but I’m constantly searching for better international sources & companies. If you have any recommendations for your region I'd love to hear them!
Looking forward to hearing your thoughts, especially on the Insights page specifically. Does this data match your experience in the market?
Thanks,
Louis (hello@rustyboard.com)

value: Show HN: RustyBoard – The largest collection of active Rust jobs and analytics

author: louispog


value: codeandcapital

value:
I built a simple dashboard to visualize the "Decapitation Effect" (the cost of missing the market's best N days).
The Logic: It compares a "Manual" strategy (sitting in cash during volatility) vs an "Automated" strategy (DCA). The visualization shows that missing the 10 best days (which usually happen during crashes) cuts returns by ~54%.
Request for Feedback: I'm trying to improve the visualization of the "Risk" metric. Right now, it feels a bit binary.
Does anyone have suggestions for a better way to visualize "Opportunity Cost" vs "Downside Protection" in the same chart?
Demo/Code Walkthrough: https://youtu.be/wGqOWfkMgEE Stack: Python (Pandas) for data, HTML5/Canvas for the frontend.

value: Show HN: My attempt to visualize 'Market Timing' risk (Python/Chart.js)

author: codeandcapital


value: ravibhatt

value: Show HN: Brickcheck.io – A website to replace my property search spreadsheets

author: ravibhatt


value: rohitghumare

value: It's an open-source project that lets you create, translate, and work with multiple agents at the same time, and more.

value: Show HN: Get recommendations or convert agent skills directly in your workspace

author: rohitghumare


value: cleverhoods

value:
My instruction files grew to 24 files, 400+ lines each. Claude kept going off-script.
Asked Claude to review and fix them. It made things different, not better.
So I built a linter. 42 rules covering structure, content, efficiency, governance, maintenance. Deterministic checks first, semantic validation for the rest.
Currently supports CLAUDE.md. Cursor, Copilot, Codex adapters coming.
v0.0.1. Open source.
CLI + MCP: https://github.com/reporails/cli
Rules (CC BY 4.0): https://github.com/reporails/rules
Early days. Looking for feedback, bug reports, and contributors.

value: Show HN: Reporails – Linter for AI coding agent instruction files

author: cleverhoods


value: emreckartal

value:
We're open-sourcing Asimov Legs, a bipedal robotic system.
A complete leg design with 6 DOF per leg, RSU ankle architecture, passive toe joints. Built with off-the-shelf components and compatible with MJF 3D printing.
What's included:
- Full mechanical CAD (STEP files)
- Motors & actuators list
- XML files for simulation (MuJoCo)
Most of the structure is MJF-printable plastic. The only part that needs CNC is the knee plate, and we spent weeks simplifying that from a 2-part assembly down to a single plate. If you don't have access to industrial MJF, casting or regular 3D printing works too.
Repo for all: https://github.com/asimovinc/asimov-v0

value: Show HN: Asimov v0, a humanoid robot legs

author: emreckartal


value: Othrya

value: Show HN: Whisper – Offline Speech-to-Text for Mac, Windows and Linux

author: Othrya


value: dlt

value: Show HN: Faultline – Self-hosted Sentry alternative for Rails

author: dlt


value:
A compact, local browser tool designed as a Chrome extension to remove background noise from videos. It includes a UI page, scripts, a WASM module, and a pre-trained model.
Files are processed locally - no server uploads.
Free, no registration or watermarks. Feedback is welcome!

value: Show HN: Remove Background Noise – AI tool for cleaning up speech on videos


value: iambenschmidt

value:
Hey HN,
If you're like me, you have sat in a meeting wondering whether this meeting is worth the cost. Is the cost of the people's time is more than whatever we are meeting about???
Well guess no longer!
Super simple little utility app.
1. Input the average meeting participant hourly/yearly pay
2. Start the meeting
3. (Optional) Share the calculator in your Zoom/Teams/Etc. for accountability
4. Dread the answer
5. (Hope) Shorten the meeting
Hope it brings you clarity (or joy).

value: Show HN: Real-time meeting cost calculator

author: iambenschmidt


value:
I built a voice dictation app for macOS mostly because I was tired of how awful Siri is and I didn't want to pay a subscription for cloud tools.
The app uses NVIDIA's Parakeet v3 (TDT) as the primary engine. Inference is handled by the FluidAudio library. It's insanely fast on M-series chips. For Intel users, I added local Whisper support ranging from Tiny up to Large v3 Turbo (quantized to save space).
The interesting part was the AI integration. I originally tried to pipeline the ASR output into Apple's Intelligence Foundation Model. It was a nightmare, because the content moderation filter blocked nearly every useful request.
So I scrapped that and moved to SwiftMLX. Now it runs Qwen 3.0 (0.6B to 8B) locally. You just set a hotkey, speak, and the local LLM handles formatting/rewriting/translation with very low latency. Zero data leaves your Mac.
It's a one-time purchase (no monthly fee). I'd love to hear what you think about the latency compared to standard Whisper implementations.

value: Show HN: I built a local macOS dictation app using Nvidia Parakeet and MLX


value: atemyipod

value:
Hey HN, we built a pure-Lua Neovim plugin that brings Cursor-style next-edit predictions to Neovim, running entirely on local models. Tab to accept, Esc to reject.
GitHub: https://github.com/BlinkResearchLabs/blink-edit.nvim
We're Blink Research Labs (https://github.com/BlinkResearchLabs) - an open research collective building AI coding tools in the open. Our philosophy is simple: if it's not open, it's not research; if it's not fast, it's not usable. We think the best AI coding tools shouldn't be locked behind $20/month subscriptions or closed-source walls.
We saw the Sweep model release a few days ago and realized the Neovim ecosystem deserved a complete, local-first, AI coding solution. So we built one.
What makes this different:
- Pure Lua, no external dependencies — No servers, no Node, no Python. Just Lua talking directly to your model backend. This matters when you're waiting for predictions on every keystroke.
- Multiple providers — Built-in support for Sweep (1.5B, optimized for next-edit) and Zeta (7B, from Zed Industries). Adding a new provider is ~50 lines of Lua.
- LSP-aware context — We fetch definitions and references for the symbol under your cursor and include them in the prompt. The model knows what foo() does before suggesting changes to it.
- Backend-agnostic — Works with llama.cpp, Ollama, vLLM, or any OpenAI-compatible server. Bring your own inference.
The plugin sends context-aware prompts based on your cursor position, recent edits, and (optionally) LSP symbols. Predictions render as ghost text inline. We handle all the edge cases: blink.cmp/nvim-cmp menu conflicts, debouncing, streaming, health checks.
Getting started takes 30 seconds:
llama-server -hf sweepai/sweep-next-edit-1.5b-GGUF --port 8000
require("blink-edit").setup({ llm = { provider = "sweep", backend = "openai", url = "http://localhost:8000" } })
The Sweep 1.5B model runs at 200+ tok/s on M-series Macs and fits comfortably on a 4GB GPU. For those with more VRAM, Zeta (7B) gives noticeably better predictions.
This is alpha software - we're iterating fast and want feedback. If you're a Neovim user who's been jealous of Cursor's tab-completion, give this a shot and tell us what breaks.

value: Show HN: Blink-Edit – Cursor-style next-edit predictions for Neovim (local LLMs)

author: atemyipod


value: LokHin

value:
Hi HN,
I’m a solo founder who recently left my job to build small, focused tools.
Page2Profit is a lightweight conversion audit tool that analyzes landing pages and highlights where revenue may be leaking — with estimated impact and prioritized fixes.
I built this after repeatedly seeing the same issues across different products:
– unclear value propositions
– missing trust signals
– weak CTAs
– unnecessary form friction
Most tools tell you what’s wrong, but not what it’s costing you.
So this audit focuses on:
• evidence-based CRO heuristics
• estimated monthly revenue impact
• severity ranking by ROI
• a clean report view + downloadable PDF
There’s a free preview report (no signup), and a one-time paid version for the full audit.
I’m mainly looking for feedback on:
– whether the revenue estimates feel reasonable
– if the report format is useful
– what would make it more actionable
Happy to answer any technical or product questions.
Thanks for reading.

value: Show HN: Page2Profit – Find where your landing page is losing revenue

author: LokHin


value: I built AdaQuiz to help developers master programming languages using adaptive quizzes and spaced repetition (SM-2). It has a free tier, works offline, and supports JS, Python, Go, Rust, Java, and C++. Feedback welcome!

value: Show HN: AdaQuiz – Adaptive Programming Quiz App with Spaced Repetition


value: parasimpaticki

value: I built Code Review Lab to help engineers practice secure code review skills. Many friends looking to switch into AppSec struggled with interview code review exercises. While there are great resources for other interview types, I couldn't find a good platform focused specifically on secure code review.<p>The platform offers interactive challenges where you review actual vulnerable code snippets (Go, PHP, etc.) and identify the exact lines with security issues. Each challenge includes context about the application and hints to guide your learning.

value: Show HN: Code Review Lab – Practice spotting vulnerabilities in code

author: parasimpaticki


value: Show HN: Actionbase – A database for likes, views, follows at 1M+ req/min


value: JoshAtticus

value:
Hey Hacker News!
Most video compression apps on Android are slow, ad-heavy, and rely on software-only encoding. I wanted something fast, native, and minimal, so I built my own: Compressor.
Compressor is FAST, like really fast, that's one of the main selling points of it. Unlike many apps that rely on software-only ffmpeg-based pipelines, Compressor uses native Media3 transformers for hardware-accelerated video compression.
Other apps are also filled with ads and trackers, Compressor has none. It doesn't have any manifest permissions (not even storage!), so there's no way to load ads or send data anywhere.
And it's native Kotlin too, which makes it small, at just over 50MB installed and less than 10MB to download. It's got Material 3 UI, including the icon, and it works on older devices too, as long as it runs Android 7 or later.
In my testing on a Pixel 8 Pro, Compressor was ~117x faster than the top Play Store result (Panda Video Compressor) when compressing a 200MB 4K video using comparable medium presets: ~11 seconds vs ~21 minutes
There's also a HEAPS of quality of life features added that make it even better, size presets for compressing videos to fit in the small requirements of platforms like Discord, ability to adjust the resolution and frame rate of the end video, H.264/H.265 selector, ability to share videos to Compressor to be compressed and out of Compressor to other apps so you never have to manually open it,
It's fully open source, currently available for download from both GitHub releases and the IzzyOnDroid F-Droid repository (with reproducible builds!)
Since this relies on hardware encoding, I’d be interested to hear how well it works (or doesn’t) on different devices and chipsets.
GitHub: https://github.com/JoshAtticus/Compressor

value: Show HN: Compressor – native Android video compression using Media3

author: JoshAtticus


value: pghqdev

value: Show HN: MinimalistNotes – In-browser private notes, no signups, free forever

author: pghqdev


value: Show HN: Claude Code Setup – Persistent context, consistent code, one workflow


value: OGsus

value: I realized that 'data quality' is often vague, so I wanted to build a deterministic score (0-100) for how stable a dataset is.

value: Show HN: Quantifying Data Drift Using Coefficient of Variation and Numba

author: OGsus


value: Show HN: Analyzed 2,285 failure threads and build a market-truth engine


value: Tanziro

value:
Hi HN,
I built EchoEntry (https://echoentry.ai) – a speech-to-text API optimized specifically for digits.
The problem: Generic STT APIs struggle with numbers. "One oh five" becomes "105" sometimes, "15" other times. For healthcare apps, warehouse systems, or IVR, this inconsistency breaks workflows.
My solution: Fine-tuned Whisper-small on 1-999 spoken numbers across 5 English accents. Gets 95% accuracy on 1-3 digit numbers.
Tech stack:
- Custom Whisper model (1.7GB)
- FastAPI backend
- Deployed on 8GB Linode
- FFmpeg for audio processing
Try it now (two commands, no signup):
# Download test audio
curl -O https://echoentry.ai/test_audio.wav
# Test the API
curl -X POST https://api.echoentry.ai/v1/transcribe \
  -H "X-Api-Key: demo_key_12345" \
  -F "file=@test_audio.wav;type=audio/wav"
Currently free beta (1,000 calls/month per key). Looking for feedback on:
1. What accuracy threshold makes this production-ready for you?
2. Are there other number-heavy use cases I'm missing?
3. Would you pay for this vs. using generic STT?
Docs: https://echoentry.ai/docs.html
Happy to answer technical questions about the fine-tuning process or deployment!

value: Show HN: Speech-to-Digits API – 95% accuracy on spoken numbers

author: Tanziro


value: Show HN: Favarr – A cross-server favourites manager for Emby/Jellyfin/Plex/ABS


value: OlaProis

value:
Disclosure: Ferrite is built using AI-assisted development (Claude). I'm sharing this openly because I think transparency is exactly what this post is about.
Someone on Hacker News called my project "open weights", arguing that without sharing the prompts and process that created the code, I was essentially doing the AI equivalent of releasing model weights without the training data. The code was visible, but the inputs weren't.
That comment led me down a rabbit hole about what "open source" actually means in an AI-assisted world.
The problem: Open source was designed assuming humans wrote code.
If you could read the code, you could understand how it was made. AI breaks that assumption. When Claude writes a function based on my prompt, the code tells you what it does, but not why it exists in that form.
My proposal: "Open Method", sharing not just the code, but the process. The prompts, the workflow, the PRDs, the decisions. Enough that someone else could understand not just what you built, but how you built it.
I wrote about this in more depth here: https://dev.to/olaproeis/beyond-open-source-why-ai-assisted-...
Some context on Ferrite:
900+ GitHub stars
Approved for Flatpak (Flathub) release
Just got code signing approved
All development methodology is documented in docs/ai-workflow/
I'm not saying everyone must share their prompts. But I think the open source community should discuss what transparency looks like when AI is writing our code.
Questions for discussion:
If you were reviewing an AI-assisted PR, what would you want to see?
Should repos have an AI_METHOD.md alongside README.md?
Does "open source" need to evolve for the AI era?

value: Show HN: Beyond Open Source: Why AI-Assisted Projects Need 'Open Method'

author: OlaProis


value: codesleep

value: Show HN: CodeSleep – No babysitting, code while you sleep

author: codesleep


value: antonreshetov

value: Show HN: Bumpy, a lightweight alternative to Changesets/Nx Release

author: antonreshetov


value: roeehersh

value: K8s operator that maintains stopped EC2 instances with warm caches — start in ~20s instead of launching fresh nodes every time.

value: Show HN: Stratos – Pre-warmed K8s nodes that reuse state across scale events

author: roeehersh


value: digitalegoai

value:
AI agents now represent a third of brand search traffic (CNET). But most web content is invisible to them — blocked by robots.txt, hidden behind JavaScript, or buried in HTML noise.
MWP (Machine Web Protocol) is an open specification for serving clean, machine-readable versions of your content. Simple text format with metadata headers. Host on your own domain at /machine/.
Spec (Apache 2.0): https://github.com/mbumpus/mwp-spec
Registry: https://machinewebprotocol.com/
Landing: https://mwp.foundation/
Would love feedback on the spec. What's missing? What would make this useful for your use case?

value: Show HN: MWP – Open spec for making web content AI-readable

author: digitalegoai


value: ivanmikhnenkov

value: Show HN: Adversarial AIs debate your question, a judge picks the winner

author: ivanmikhnenkov


value: spacemule

value:
A few weeks ago I could barely code in python, and I could not code a single line of go. After seeing claude handle a work project impressively, I decided to try using it to teach me to code. I asked it to scaffold projects, write todos above the functions, and tell me a reasonable order to work in. This doesn't teach software design, but it really helps get over the hump of learning the ecosystem and standard libraries.
Now, I still can't program unassisted, but I feel confident enough to read others' code and maybe even submit a small PR to fix a bug.
This is my first attempt at a generally useful project. It's a mutating admission webhook. This is still a WIP, but it's working and I'm using it on my own k3s cluster. It adds oauth2-proxy to pods that need authentication. On the cluster, I replaced Authentik with Zitadel, and I needed something to fill in the role of Authentik's proxy provider.
Since so many people are using and becoming frustrated with AI now, I hope this can be some inspiration to use AI as a tool to learn something new instead of as an assistant. Hopefully the more experienced programmers here can let me know what about this looks like slop (I assume it does). I'm afraid if I keep this up, I'll learn to program too much like claude.

value: Show HN: Oauth2-Proxy-Injector

author: spacemule

title: Show HN: Oauth2-Proxy-Injector


value: rngacc

value: Show HN: Tfstate-audit – search/diff Terraform state history (S3/GCS/Azure/HCP)

author: rngacc


value: neochief

value:
Hi folks! My name is Alexander Shvets. People know me best as an admirer of raccoons and the creator of Refactoring.Guru
Today I'd like to show you the project I've been working on for the past two years: https://gitbybit.com
It's a Git course that runs inside your code editor (VS Code, Cursor, and friends), so you learn Git by using it in real dev environment. It's well-designed and illustrated.
## Who is it for?
The course will be most helpful for three groups of people:
- Developers who “use Git” but mostly as a black box. You know a few commands, but you want to actually understand what you’re doing.
- Builders returning to code (PMs, designers, ex-devs) who now use AI tools for prototypes and internal tools, and need their Git muscles back.
- Hobby coders and beginners who want a practical, confidence-building path from zero to “I can work with Git.”
## What makes it different?
I designed GitByBit as a modern way to learn Git (if we can still say so about a project that doesn't use AI). It's story based, you learn about everything gradually, one concept built upon another. It's is also hyper-focused on practice: building muscle memory for commands, using real Git, real IDE tools, etc.
That's possible because of the unique format: the course is integrated right into your code editor (assuming it's VS Code, Cursor, or any of the clones). It can also be run online via GitHub Codespaces. This format allows it to achieve some pretty cool things:
- Real Git, editor and terminal. You're always using real stuff! Once you finish the course, you're one shortcut away (Open New Window, Ctrl+Shift+N) from applying everything you've just learned about Git in your next project.
- Instant feedback. The course can check the results of your actions, explain errors, suggest workarounds, etc. You don't have to jump between a web page with instructions and the terminal, or search for explanations of cryptic Git errors. It's all in one place.
- Respects your time. The content is presented in bite-sized chunks, which helps you keep focus and stay engaged. No endless videos you have to sit through. The main course can be completed in one sitting, in an evening.
- Gitopedia. While progressing through the course, you build your personal in-editor Git reference, unlocking bits of supplemental material. They go into your personal knowledge base, a thing I called Gitopedia. You can pull up the Gitopedia as a separate tab in the editor, or arrange it to be opened in parallel at all times. It also serves as a map of what you've learned so far.
- Illustrated. There are cool handmade illustrations (see https://gitbybit.com/blog/0005-illustrations)
## What's covered in the course?
There are two parts.
1. The FREE main course, focuses on Git essentials: things that you need to know to work on your personal projects. Setting up and configuring Git, working with the terminal, the staging area, commits, branches, history, remote repos, etc.
The course teaches Git in terminal first, but also shows how to achieve the same thing via graphical user interface of the editor.
Apart from learning Git itself, you also get insights on using the terminal effectively (navigating history, using autocomplete, etc.), learn about software release cycle, semantic versioning, licenses, best practices and more.
2. Optional paid add-on (extra practice and team workflows):
- Selective staging and resetting changes.
- Different ways to clean up the repo or ignore unwanted changes.
- A detective scenario where you investigate project crashes using git history and git blame.
- A deep dive into merging/rebasing branches.
- And my favorite: the full GitHub pull request workflow, from forking someone's repo to updating it according to the maintainer's demands, and the eventual merge.
Enjoy and have fun!

value: Show HN: GitByBit — Git course integrated into VSCode and Cursor

author: neochief


value: bryanmikaelian

value: Show HN: Manpage.dev – Turn your GitHub profile README into a Unix man page

author: bryanmikaelian


value: aggeeinn

value:
Last week, Google research published details on GIST (Greedy Independent Set Thresholding), a new protocol presented at NeurIPS 2025. I was fascinated by the paper, so I built a tool to visualize the "No-Go Zones" (redundancy radius) it describes.
The Tool: https://websiteaiscore.com/gist-compliance-check
The Context (The Paper): To understand the tool, you have to understand the problem Google is solving with GIST: redundancy is expensive. When generating an AI answer , the model cannot feed 10k search results into the context window—it costs too much compute. If the top 5 results are semantically identical (consensus content), the model wastes tokens processing duplicates.
The GIST algorithm solves this via Max-Min Diversity:
Utility Score: It selects a high-value source.
The Radius: It draws a mathematical conflict radius around that content based on semantic similarity.
The Lockout: Any content inside that radius is rejected to save compute, regardless of domain authority.
How my implementation works: I wanted to see if we could programmatically detect if a piece of content falls inside this "redundancy radius." The tool uses an LLM to analyze the top ranking URLs for a specific query, calculates the vector embedding, and measures the Semantic Cosine Similarity against your input.
If the overlap is too high (simulating the GIST lockout), the tool flags the content as providing zero marginal utility to the model.
I’d love feedback on the accuracy of the similarity scoring.

value: Show HN: Analyzing Semantic Redundancy in LLM Retrieval (Google GIST Protocol)

author: aggeeinn


value: embedding-shape

value: Show HN: One Human + One Agent = One Browser From Scratch in 20K LOC

author: embedding-shape


value: NIkMOkhn

value:
Hi HN,
I'd like to share a project I've been working on – an affiliate program for EUROASIA Insurance, a major insurance company in Uzbekistan. The goal is to create a new income stream for content creators and individuals in the region.
How it works:
•
Sign up: A quick, free registration process.
•
Get a unique link: You get a unique affiliate link and promo code.
•
Share: You share the link with your audience, friends, or clients.
•
Earn: You get up to 20% commission for every insurance policy sold through your link.
We've tried to make it as simple as possible, with a transparent dashboard to track clicks, sales, and earnings. Payouts are processed within 3 business days.
Why this is interesting:
While affiliate programs are common in many parts of the world, they are still a relatively new concept in Uzbekistan. We're hoping this will provide a new way for people to monetize their online presence, especially in a market where traditional ad revenue can be unpredictable.
We're particularly interested in feedback on:
•
The commission structure (is 20% competitive?)
•
The user experience of the affiliate dashboard.
•
How we can better support our affiliates.
I'm here to answer any questions you have. Thanks for checking it out!

value: Show HN: An affiliate program that pays up to 20% for insurance referrals

author: NIkMOkhn


value: tajchert

value: Easiest way to catch up with top HN news after holidays or crunch-time.

value: Show HN: Catch-HN top stories from any date range

author: tajchert


value: I’ve released a legacy mod that exposes The Sims 1 via MCP. The project started as a joke and demonstrates a super fast reverse engineering workflow using Claude Code, Ghidra and GhydraMCP.

value: Show HN: Sims 1 Legacy MCP

title: Show HN: Sims 1 Legacy MCP


value: mikeayles

value:
Creator here. Third in a series of running DOOM on engineering tools - KiDoom rendered walls as PCB traces in KiCad, ScopeDoom piped vectors through a headphone jack to an oscilloscope.
This one exports frame geometry to OpenSCAD, a parametric CAD tool. The browser version uses Three.js to render the same geometry the desktop version writes to .scad files.
The desktop version was stuck at slideshow framerates until I fixed OpenSCAD's WASM renderer for another project - the npm package is from 2022 and silently ignores the Manifold flag. Switching to the 2025 build took renders from 2 minutes to 2 seconds. (Writeup: https://phaestus.app/blog/blog0031)
But openscad-wasm isn't a renderer, it's a compiler. Each frame was compiling to STL then rendering - maybe 1fps sequential, better parallelized but with ~1s latency. Fine for previewing an item, but as a rendering pipeline it's no good for real time playback.
So I removed openscad-wasm entirely and wrote a custom parser that converts OpenSCAD code to an AST, evaluates it to geometry, and renders via Three.js. The scad code is the only input - what you see comes from the same .scad you can copy, download, and run in desktop OpenSCAD or the playground to validate.
Technical writeup: https://www.mikeayles.com/#openscad-doom
YouTube: https://youtu.be/l9nnV-mO4wY
Desktop version source: https://github.com/MichaelAyles/openSCAD-DOOM
Web version source: https://github.com/MichaelAyles/openSCAD-DOOM-web

value: Show HN: Doom rendered in OpenSCAD geometry, now playable in browser

author: mikeayles


value: HeleneBuilds

value:
Hi HN!
I’m Hélène. My husband and I are builders from Belgium, and we’ve spent the last few months building a side project called 13 Virtues.
The idea comes from Benjamin Franklin’s personal character system. Instead of tracking many habits at once, he focused on one virtue per week (Temperance, Silence, Order, etc.), cycling through 13 virtues over 13 weeks, then repeating the cycle. He documented this practice for many years.
We wanted an app that follows this structure strictly, rather than another flexible habit tracker. One virtue at a time. One day at a time. Repeat.
You can try the ledger directly on the homepage without creating an account. You can mark faults for today and see the current virtue with Franklin’s original quotes:
https://www.13-virtues.com
Why we built it:
We were frustrated with productivity apps that optimize for streaks and metrics rather than reflection. Franklin’s system felt refreshingly constrained and intentional, and we wanted something we’d actually use ourselves. My husband handled the engineering; I focused on product and design.
Pricing model:
We deliberately avoided subscriptions.
- Free tier: the full 13-week cycle and daily ledger
- Lifetime upgrade ($79 launch price): long-term history beyond the current cycle, guided reflections, data export, and a downloadable Modern Virtue Guide (PDF) that explains the method and its rationale in more depth.
Franklin’s system predates SaaS by a few centuries, and a monthly fee felt wrong for something meant to be practiced quietly over years.
Tech:
- Backend: Laravel
- Frontend: Vue (Inertia)
- CSS: Tailwind
- Hosting: Hostinger
Built over ~12 weekends.
We’ll be around today (CET) to answer questions — happy to discuss the implementation, the pricing decision, or Franklin’s original writings. Thoughtful UI/UX feedback is especially welcome.

value: Show HN: 13-Virtues – A tracker for Benjamin Franklin's 13-week character system

author: HeleneBuilds


value:
I'm an expat in Bangkok who can read Thai menus but freezes the moment someone speaks to me. Duolingo didn't help, I needed actual speaking practice, but tutors are expensive and scheduling is a pain.
So I built speaklanguageonline.com - a voice call with an AI that speaks Thai (or Vietnamese), listens to your attempts, and gives you one gentle correction at a time. No typing, no flashcards, just talking.
Tech:
OpenAI Realtime API (WebRTC) for speech-to-speech
Next.js 14 + Vercel
No transcription step - the model processes audio directly, which preserves tone (critical for Thai's 5 tones)
What makes it different from ChatGPT voice:
- Tuned for slow, patient corrections (not conversational chat)
- One correction per turn (anxiety-inducing to get 5 things wrong at once)
- Corrections explained in your native language
- 3-minute session cap to keep it focused
Pricing: Credits, not subscriptions. You pay only for minutes used. I hate subscription guilt as much as you do.
Current state: Thai and Vietnamese work well. Adding Spanish, Hindi, Mandarin soon — OpenAI's model handles them but quality varies.
What I learned:
Realtime API latency is ~300-500ms which feels natural for conversation
Prompting for "one correction only" took way more iteration than expected
Tonal languages need explicit instruction to focus on tone mistakes
Would love feedback, especially from anyone who's built voice-first apps or is learning a language.

value: Show HN: I built a voice-only AI language tutor using OpenAI's Realtime API


value: Show HN: Trix – A terminal music player written in Rust


value: furkankoseoglu

value:
Hi HN,
I’m Furkan. I built Lenma — a voice assistant for macOS that lets you control your Mac and your productivity tools using voice.
Try it here: lenma.app
Tech note: Wake word detection runs fully local using openWakeWord, integrated in Rust.
What it does
1. Integrations (work apps)
Google Calendar, Slack, Notion, Linear, Apple Notes, Mail, Calendar, Reminders
- “What do I have today?”
 - “Create a Linear issue…”
 - “Send this to Slack…”
2. macOS control
- “Set volume to 30%”
 - “Move this window to desktop 3”
 - “Split screen left and right”
3. Dictation anywhere.
4. Brain Book
Save what you’re looking at on your screen into notes/memory
- “Save this to Brain Book”
5. Real-time web search for grounded answers
weather, currency, quick facts, etc.
6. Custom voice commands
Trigger chains of bash/scripts, keyboard shortcuts, and clicks by voice.
Why I built it
I started Lenma after wrist/RSI issues forced me to reduce keyboard/mouse time. Dictation helped, but I wanted a voice interface that could take actions across macOS and my tools—not just type text.
Feedback I’d love
What’s the one macOS action you’d want to trigger by voice every day?
For Raycast/Alfred power users: what would make voice control genuinely useful (and not annoying)?
Thanks — I’ll be around to answer anything.

value: Show HN: Lenma – A Voice Assistant for macOS

author: furkankoseoglu


value: WolfOliver

value: Show HN: MonsterWriter – An Overleaf Alternative with a Better Free Plan [video]

author: WolfOliver


value: atimcha

value: Show HN: Lichess.el – Play Lichess Inside Emacs

author: atimcha


value: ogandreakiro

value:
Hey HN,
We’ve been building browser agents for a while. In production, we kept converging on the same pattern: deterministic scripts for the happy path, agents only for edge cases. So we built Demonstrate Mode.
The idea is simple: You perform your workflow once in a remote browser. Notte records the interactions and generates deterministic automation code.
How it works:
- Record clicks, inputs, navigations in a cloud browser
- Compile them into deterministic code (no LLM at runtime)
- Run and deploy on managed browser infrastructure
Closest analog is Playwright codegen but:
- Infrastructure is handled (remote browsers, proxies, auth state)
- Code runs in a deployable runtime with logs, retries, and optional agent fallback
Agents are great for prototyping and dynamic steps, but for production we usually want versioned code and predictable cost/behavior. Happy to dive into implementation details in the comments.
Demo: https://www.loom.com/share/f83cb83ecd5e48188dd9741724cde49a
--
Andrea & Lucas,
Notte Founders

value: Show HN: Build Web Automations via Demonstration

author: ogandreakiro


value: drpancake

value: Show HN: WhyFi – Figure out why your Wi-Fi is bad and fix it

author: drpancake


value: mtauraso

value: Show HN: IOPS Profiler – Jupyter magic to measure I/O operations per second

author: mtauraso


value: tullie

value:
Hi HN,
I’m Tullie, founder of Shaped. Previously, I was a researcher at Meta AI, worked on ranking for Instagram Reels, and was a contributor to PyTorch Lightning.
We built ShapedQL because we noticed that while retrieval (finding 1,000 items) has been commoditized by vector DBs, ranking (finding the best 10 items) is still an infrastructure problem.
To build a decent for you feed or a RAG system with long-term memory, you usually have to put together a vector DB (Pinecone/Milvus), a feature store (Redis), an inference service, and thousands of lines of Python to handle business logic and reranking.
We built an engine that consolidates this into a single SQL dialect. It compiles declarative queries into high-performance, multi-stage ranking pipelines.
HOW IT WORKS:
Instead of just SELECT , ShapedQL operates in four stages native to recommendation systems:
RETRIEVE: Fetch candidates via Hybrid Search (Keywords + Vectors) or Collaborative Filtering.
FILTER: Apply hard constraints (e.g., "inventory > 0").
SCORE: Rank results using real-time models (e.g., p(click) or p(relevance)).
REORDER: Apply diversity logic so your Agent/User doesn’t see 10 nearly identical results.
THE SYNTAX: Here is what a RAG query looks like. This replaces about 500 lines of standard Python/LangChain code:
SELECT item_id, description, price
FROM

  -- Retrieval: Hybrid search across multiple indexes

  search_flights("$param.user_prompt", "$param.context"),

  search_hotels("$param.user_prompt", "$param.context")

WHERE

  -- Filtering: Hard business constraints

  price <= "$param.budget" AND is_available("$param.dates")

ORDER BY

  -- Scoring: Real-time reranking (Personalization + Relevance)

  0.5 * preference_score(user, item) +

  0.3 * relevance_score(item, "$param.user_prompt")

LIMIT 20
If you don’t like SQL, you can also use our Python and Typescript SDKs. I’d love to know what you think of the syntax and the abstraction layer!

value: Show HN: ShapedQL – A SQL engine for multi-stage ranking and RAG

author: tullie


value: britojosepha

value:
Hi HN, I built this because digging through bookmarks and open tabs is too slow. I wanted to just open a new tab and start typing without touching the mouse.
So I made a way to open a single site (or a folder of multiple sites) without taking my hands off the keyboard. I also added features to close your open tabs and save them into folders so you can pick up where you left off in a single click.
It supports terminal style commands (like = for math or r/ for Reddit). Please let me know if you have any feedback or desired features :)

value: Show HN: Terminal style start page for bookmarks and open tabs

author: britojosepha


value: cmkr

value: Show HN: We Built the 1. EU-Sovereignty Audit for Websites

author: cmkr


value: We’ve been building CUGA, an open-source generalist agent for reliable browser+API automation with Save & Reuse, policy modes, OpenAPI/MCP integration, and strong results on WebArena/AppWorld. Live demo link above. Happy to answer questions and get feedback.

value: Show HN: CUGA – Configurable Generalist Agent (HuggingFace Live Demo)


value: shujip

value:
I’m Lu. I spent the last year falling into the classic trap: building solutions first, then looking for problems. After launching two projects that got zero traction, I realized I needed to validate demand before writing code.
I started manually browsing subreddits like r/SaaS, r/marketing, and r/smallbusiness, looking for posts containing phrases like "how do I," "why is X so hard," or "I hate Y." It worked, but it was unscalable.
So, I automated it. I built Nichestarter.ai.
How it works (The Stack):
Ingestion: I try to scrape daily threads from high-signal subreddits (and soon G2 reviews).
Filtering (The hard part): I run raw posts through a cheaper model to filter out noise, general questions, and low-effort rants.
Analysis: Valid complaints are passed to llm to analyze "Willingness to Pay" (based on sentiment and business context) and "Solution Complexity."
Matching: I built a match engine that pairs these problems with user skills (e.g., "React Dev" + "Marketing Pain Point").
The Result: A daily feed of "Gap Analysis." Instead of just seeing a Reddit post, you see the core pain point, the customer segment, and a generated MVP roadmap.
It’s currently in beta. I have a free tier that sends a weekly digest of the best opportunities found.
I’d love to hear your feedback on the matching logic—specifically, does the "Opportunity Score" feel accurate to you?
Thanks!

value: Show HN: Nichestarter – Stop guessing what to build. Find validated pain points

author: shujip


value: Yank is a new terminal-based tool for concurrent file downloads. It's written in Haskell and focuses on performance and a simple user experience.

value: Show HN: Yank = gdown + wget + Haskell

title: Show HN: Yank = gdown + wget + Haskell


value: fwee

value: Show HN: Vibe Caffeine – Prevents Mac sleep while AI coding tools work

author: fwee


value:
I built a collection of one-page printable templates for decisions, prioritization, and         reflection. The twist: they're designed to be filled out with pen and paper, not digitally.
Why paper? Writing by hand is slow—and that's the point. When I type, I can outpace my thinking. When I write, I catch myself mid-sentence realizing "wait, that's not actually true." The friction is a feature.
What's included:
 - Decision Canvas (pros/cons + second-order effects + cognitive bias check)
 - Eisenhower Matrix (urgent vs. important)
 - Stop/Start/Continue audit
 - Rubber Band Model (what's pulling me forward vs. holding me back)
 - Cognitive Bias Checklist (pre-flight check before any big decision)
Tech: All templates are written in Typst. GitHub Actions compiles to PDF, generates PNG thumbnails, and auto-generates the README from metadata comments in each .typ file. Zero manual release process.
Philosophy: If a decision is easily reversible, don't use a template—just move. These are for the choices that keep you up at night.
GitHub: https://github.com/philippnagel/thinkingtemplates
I'd love feedback on which templates are actually useful vs. overthinking-theater, and ideas for new ones.

value: Show HN: Printable Thinking Templates – Mental Models You Fill Out by Hand


value: sureshcsdp

value:
I've been building CleanCloud (open-source cloud cost scanner) and discovered the biggest adoption blocker wasn't our feature set
It was InfoSec approval.

  The Problem: The Code Audit Wall

  Every enterprise we talked to had the same process:
  1. SRE team loves the tool, wants to use it
  2. InfoSec requires security review before production use
  3. Security team must audit the entire codebase to verify read-only claims
  4. Process takes 2-4 weeks (or gets stuck in backlog indefinitely)

  One CISO told us: "I don't care if your README says 'read-only'. I need to verify you're not calling DeleteBucket() anywhere in 10,000 lines of Python."

  Fair point. But this kills adoption velocity.

  The Insight: Don't Ask Them to Trust Your Code

  The breakthrough came from asking: "Who do InfoSec teams already trust?"

  Answer: AWS and Azure. They already trust the cloud provider's IAM enforcement.

  So instead of asking them to audit our code, we provide:

  1. A 30-line JSON IAM policy (read-only by design)
  2. A verification script they can run to prove it's safe
  3. OIDC setup (GitHub Actions) with no stored credentials
  4. Runtime safety tests that fail if we call forbidden APIs

  The IAM Proof Pack: https://github.com/cleancloud-io/cleancloud/tree/main/docs

  The Result

  InfoSec teams now audit a 30-line JSON file instead of our entire codebase. Trust is enforced by AWS/Azure IAM, not by promises in our README.

  A colleague who reviewed it said:
  > "I specifically love the IAM Proof Pack approach. By requiring a separate, verifiable Read-Only IAM role, you shift trust from your code to the Cloud Provider's enforcement. They don't have to audit your Python code line-by-line—they just verify the JSON policy is safe."

  This reduced our InfoSec approval time from 2-4 weeks to same-day in several cases.

  Technical Details

  The approach works because:

  1. **Verifiable IAM Policy**: The read-only policy is declarative, easy to audit
     ```json
     {
       "Version": "2012-10-17",
       "Statement": [{
         "Effect": "Allow",
         "Action": ["ec2:Describe*", "s3:List*", "s3:GetBucketTagging"],
         "Resource": "*"
       }]
     }

  2. OIDC-First: No long-lived credentials, temporary tokens only
    - GitHub Actions → AWS STS AssumeRoleWithWebIdentity
    - Azure Workload Identity Federation
    - Zero secrets stored in CI/CD
  3. Runtime Guards: Our test suite mocks AWS/Azure SDKs and fails if forbidden methods are called
  def test_aws_runtime_readonly():
      with patch('boto3.client') as mock:
          mock.return_value.delete_bucket.side_effect = AssertionError("Forbidden!")
          scan_aws()  # Must not call delete_bucket
  4. Static Analysis: AST parsing blocks dangerous imports/calls at CI time

  Why This Matters

  If you're building DevOps/security tools that need cloud access, the "trust me, it's read-only" approach doesn't scale. InfoSec teams need verifiable guarantees, not promises.

  Shifting trust from your code to the cloud provider's enforcement makes security review tractable.

  Open Questions

  - Is there a better way to prove read-only behavior programmatically?
  - How do other cloud tools handle InfoSec approval?
  - Should this be a standard pattern for cloud security tools?

  GitHub: https://github.com/cleancloud-io/cleancloud
  Docs: https://github.com/cleancloud-io/cleancloud/blob/main/docs/infosec-readiness.md

  Happy to discuss the approach or share more details about what worked (and what didn't).

value: Show HN: How we solved the InfoSec adoption blocker for cloud tools

author: sureshcsdp


value: tmarois

value: The foundation for crafting AI-powered applications in Laravel. Easily implement and manage your AI Agents and tools.

value: Show HN: Foundation for AI Development in Laravel

author: tmarois


value:
I built WatchRoom to watch YouTube with strangers and discover new content together.
Browse public rooms to see what others are watching - gaming streams, music, documentaries - and join instantly. Or create your own and see who shows up. No login needed.
Features:
- Public room list: Find and join rooms in one click
- Real-time P2P sync: Play/pause/seek stays perfectly in sync
- Chat + floating emoji reactions
- Private rooms with password for friends
I've discovered genres I never knew I'd enjoy just by joining random rooms.
Tech: React 19, Go, WebRTC P2P DataChannel.
Try it: https://watchroom.ponyo877.com/en/

value: Show HN: WatchRoom – Watch YouTube with strangers, discover new content together


value:
Totalizer is a real-time yes/no polling app that uses P2P (WebRTC) for instant sync across all participants.
I built this because I wanted a quick way to play confession games at parties with friends – "Do you have a crush on
someone here tonight?" "Are you actually pretty drunk right now?" – but every polling app I tried required accounts
or had annoying delays. I just wanted to share a link and get everyone voting immediately.
How it works: Create a room, share URL or QR code. Type your yes/no question. Everyone votes anonymously, results
appear with confetti.
Tech: React 19, WebRTC for P2P, Go + Redis backend. Questions and results travel peer-to-peer; the server only
handles auth and atomic vote counting (Redis Lua scripts prevent duplicates).
Great for party games, icebreakers, and quick group decisions. Feedback welcome!

value: Show HN: Totalizer – P2P yes/no polling for meetings, no signup required


value: mvyshnyvetska

value:
Hi HN — I built semantic-diff for myself, and it turned out surprisingly useful.
Regular git diff shows what changed. semantic-diff tries to answer:
– why was this change made?
– what could break?
– what should the reviewer focus on?
It gives you a ranking from critical to low, with review questions prioritized.
The funny part: I ran it on its own commits during development. The tool roasted me harder than any reviewer I've had )))
Runs locally, hooks into pre-push, also works as a GitHub Action.
Would love feedback, especially from people doing code review at scale.

value: Show HN: Semantic-diff – understanding intent, risk and impact behind Git diffs

author: mvyshnyvetska


value: tokkyokky

value:
Hey HN,
A CSV parser using Go 1.26's experimental simd/archsimd package.
I wanted to see what the new SIMD API looks like in practice. CSV
parsing is mostly "find these bytes in a buffer"—load 64 bytes, compare,
get a bitmask of positions. The interesting part was handling chunk
boundaries correctly (quotes and line endings can split across chunks).
- Drop-in replacement for encoding/csv
- ~20% faster for unquoted data on AVX-512
- Quoted data is slower (still optimizing)
- Scalar fallback for non-AVX-512
Requires GOEXPERIMENT=simd.
https://github.com/nnnkkk7/go-simdcsv
Feedback on edge cases or the SIMD implementation welcome.

value: Show HN: I built a CSV parser to try Go 1.26's new SIMD package

author: tokkyokky


value:
FitVow is my personal commitment-device experiment: I lock funds in a smart contract for 12 weeks, define weekly fitness goals, and if I miss a week a penalty becomes enforceable.
Enforcement is permissionless: anyone can call the contract and a portion of the penalty is paid to the caller; the rest goes to a charity (Giveth).
Weekly activity data comes from my smartwatch (via Samsung Health / Health Connect), synced by an Android app that publishes the weekly activity on-chain.
The site is mostly a viewer for on-chain state. Full write-up / architecture / security notes in the first comment.

value: Show HN: FitVow – a smart contract that fines me if I miss weekly fitness goals


value: ryanrasti

value: Show HN: ExoAgent – Security kernel for AI agents

author: ryanrasti


value: dawsonbotsford

value:
I got frustrated by npm run's cold start time, so I built nr.
It's a drop-in replacement written in Rust. No config needed – just use `nr test` instead of `npm run test`.
Especially useful if you're using AI coding assistants that run npm commands constantly.

value: Show HN: Nr – 26x faster NPM run replacement

author: dawsonbotsford


value:
I built confcrypt to encrypt sensitive values in config files – hostnames, usernames, URLs stay readable.
Makes reviewing configs and debugging much easier than tools that encrypt everything.
Think sops, but simpler.
Multiple key types as recipients:
- Native age keys (X25519)
- SSH keys (ed25519, RSA) – use your existing keys
- FIDO2 devices (YubiKey 5, SoloKey, etc.) via hmac-secret
- YubiKey OTP via HMAC challenge-response
Hardware keys derive the private key on-demand with a touch – never stored on disk.
How it works:
- Pattern-based: only keys matching /password$/, /api_key$/, etc. (configurable) get encrypted
- Values encrypted with AES-256-GCM, key wrapped per recipient
- `confcrypt check` for CI – exits 1 if unencrypted secrets found

value: Show HN: Confcrypt – Encrypt Secrets in YAML/JSON Configs with FIDO2/Age/SSH


value: joeeverjk

value:
I’ve spent the last few months building Frigatebird, a high performance columnar SQL database written in Rust.
The goal wasn't just "make it work," but to use every systems programming trick available to maximize throughput on Linux.
Frigatebird is an OLAP engine built from first principles. It features a custom storage engine (Walrus) that uses io_uring for batched writes, a custom spin lock allocator, and a push-based execution pipeline. I explicitly avoided async runtimes in favor of manual thread scheduling and atomic work stealing to maximize cache locality. Code is structured to match the architecture diagrams exactly.
currently it only supports single table operations (no JOINS yet), would love to hear your thoughts on it.

value: Show HN: Frigatebird – high performance OLAP database built on io_uring

author: joeeverjk


value: PrismShadow

value: Show HN：AgentHub - Unified, Stateful SDK for All SOTA LLMs and Agent Executions

author: PrismShadow


value:
I made this because most cleanup tools don't show what they're deleting.
This one lets you browse everything first and exclude what you want to keep. deletes go to Trash by default.

value: Show HN: Simple terminal UI for cleaning macOS


value: jonnyhere

value:
I have a mass of AI subscriptions. ChatGPT, Claude, Perplexity, Gemini. My workflow became: ask Claude, then paste the same question into ChatGPT to sanity-check, then maybe ask Perplexity if I need sources. Five tabs, constant copy-pasting.
Council just runs your prompt against multiple models at once and shows responses side-by-side. That's it.
A few things I noticed while building this:
1. Models disagree with each other way more than I expected. Ask anything slightly subjective or recent, and you'll get meaningfully different answers. It's made me much more skeptical of treating any single response as "the answer."
2. Different models have different failure modes. Claude tends to be cautious and hedge. GPT is confident even when wrong. Perplexity gives sources but sometimes misreads them. Seeing them together makes these patterns obvious.
3. For code, I actually like getting 2-3 different approaches. Even if one is clearly better, seeing alternatives helps me understand the tradeoffs.
Tech: Next.js, OpenRouter for model access, streaming responses in parallel. The annoying part was handling the UI when models respond at different speeds – you don't want the layout jumping around.
No login required to try it. Feedback welcome, especially on what's broken or annoying.
https://usecouncil.app/

value: Show HN: I query multiple LLMs in parallel because I don't trust any single one

author: jonnyhere


value:
Hi HN,
I built Magpie because I was tired of AI code reviewers being too "nice."
Most AI tools just say "LGTM" or nitpick formatting. To fix this, Magpie uses an adversarial approach: it spawns two different AI agents (e.g., a Security Expert and a Performance Critic) and forces them to debate your changes.
They don't just list bugs; they attack each other's arguments until they reach a consensus. This cuts down on hallucinations and lazy approvals.
Features:
Adversarial Debate: Watch Claude and GPT-4o fight over your code.
Local & CI: Works on local files or GitHub PRs.
Model Agnostic: Supports OpenAI, Anthropic, and Gemini.
The Experiment: This is also an experiment in "coding without coding." I didn't write a single line of TypeScript for this project manually. The entire repo was built using Claude Code.
I'd love to hear your feedback—especially if you manage to make the models get into an infinite argument.
https://github.com/liliu-z/magpie

value: Show HN: Magpie – I built a CLI where AIs argue about my code


value: ssut

value: Show HN: WSL2 HyperV Firewall Manager – GUI App for WSL2 Firewall Management

author: ssut


value: etoonoptima

value: I built this app that works kind of like a mix of ChatGPT and Cursor (or Claude Code, GitHub Copilot, etc.) for non-programming use cases. I think it's important to own your data and tools - that's why I went FOSS and made the underlying data portable (plain files with a git-like sync). ChatGPT, Gemini, and other big players will try to lock people in and then start squeezing at some point, so we need to have a counterbalance in the form of FOSS that can match them in features and be a viable alternative.<p>It's not a business yet and I don't plan to do subscriptions or open-core, but I'm considering ways to do consulting with the product: setting up workspaces at companies and helping with custom workflows.

value: Show HN: Local-first AI workspaces with tiling tabs like in VSCode [FOSS]

author: etoonoptima


value: suryaelidanto

value:
Hello HN,
I'm a solo developer working on design systems and frontend engineering. I built Link2Slide because I found existing tools for creating LinkedIn carousels were either too expensive, required signups, or were just too complex for quick edits.
Link2Slide is a simple, free tool that lets you:
1. Paste a URL (article, blog) or raw text.
2. Auto-generate summarized slides using AI.
3. Customize the styling (inspired by high-end design systems).
4. Export directly to PDF.
There are no ads, no VC, and no paywalls—just a project built with passion to help the community.
I’d love to hear your feedback on the UX and the generated output quality.
Thanks!

value: Show HN: Link2Slide – Free tool to turn any URL/text into LinkedIn Carousels

author: suryaelidanto


value: chetstriker

value:
PenPeeper – An Open-Source Pentesting Engagement Manager (with Optional AI)
Most pentesting tools I’ve used fall into one of two buckets:
absurdly expensive enterprise SaaS
open-source tools that don’t help once scanning is done
PenPeeper is my attempt to fix that.
What it is
A free, open-source, self-hosted pentesting engagement manager that focuses on the boring but critical parts:
scoping & engagement tracking
vulnerability management
reporting
tying everything together in one workflow
The AI part (optional, not magic)
PenPeeper can integrate with local or external LLMs (Ollama, LM Studio, ChatGPT, Claude, Gemini, OpenRouter).
Runs on Windows (via WSL integration), MacOS, Linux
The goal isn’t “AI replaces pentesters.”
It’s:
faster vuln analysis
better first-draft reports
less copy-pasting between tools
You can run it fully local. You can turn AI off entirely.
Why I built it
Commercial tools are overpriced and locked down.
Most open-source tools stop at scanning.
Reporting is still manual, repetitive, and error-prone.
That gap is what PenPeeper is trying to cover.
Status
Early but stable
Actively developed
Looking for real pentester feedback (not hype)
Links
Site: https://penpeeper.com
GitHub: https://github.com/chetstriker/PenPeeper
Feedback I want
What part of your pentest workflow is still the most painful?
Where does AI actually help vs get in the way?
What would make this worth using on a real engagement?
Happy to answer technical questions or take criticism.

value: Show HN: PenPeeper–An Open-Source Pentesting Engagement Manager (Optional AI)

author: chetstriker


value:
Hi HN, I built Prism, a production ready iOS app for a daily AI digest.
What’s different vs typical AI news feeds:
 • Evidence badges per story so you can judge source quality fast (Official, Reputable, Paper, Community)
 • Try This prompts per story so you can immediately test ideas, tools, or workflows
 • Save and tag items (Read later, Build, Research) plus Explore search for past digests
 • Smart notifications for the daily drop
It’s freemium: free gets a few items, Pro unlocks all daily items plus full archive and notifications.
App link: https://apps.apple.com/en/app/prism-trusted-ai-digest/id6757...
Feedback I’d love:
 • Which evidence levels feel most useful
 • Ideal daily volume (7 vs 10)
 • Any missing sources you wish every AI digest covered

value: Show HN: Prism, a trusted AI news digest for iOS