value: drankou

value:
Hey HN, I built Ring Widget because I got tired of opening the Oura app every time I wanted to check latest values.
Ring Widget adds home screen and lock screen widgets for your Oura Ring that native app lacks — cardio age, VO2 max, stress time and much more.
The app connects to Oura's v2 API via OAuth and refreshes your widget data throughout the day. No account creation, no data stored on our servers — everything stays on your device.
Would love feedback, especially from other Oura users. Which widgets are you currently missing?
https://ringwidget.app

value: Show HN: Ring Widget – iOS/macOS Widgets for Your Oura Ring

author: drankou


value: lowercasename

value:
I was recently thinking about mixtapes.
Mixtapes were like a personalized way to discover music, free of algorithms or AI. If I wanted an introduction to a band or genre my friend loved, I'd ask them for a mixtape. Or I might get a mixtape from a cutie and discover a whole new kind of music.
MixPal is a tiny, federated mixtape sharing service. The idea is: log into MixPal with your Fediverse account (Mastodon, GoToSocial, Pleroma, etc.). Ask the Fediverse for a mixtape. The bot will boost your request, and maybe someone will be inspired to reply with the perfect playlist.
MixPal is brand new, so it will cherish your follows, requests, and replies!
Happy to chat about the technical decisions here, even happier to chat about mixtapes.

value: Show HN: MixPal, a tiny social network for sharing mixtapes by request

author: lowercasename


value:
I built qlog because I got tired of waiting for grep to search through gigabytes of logs.
qlog uses an inverted index (like search engines) to search millions of log lines in milliseconds. It's 10-100x faster than grep and way simpler than setting up Elasticsearch.
Features:
- Lightning fast indexing (1M+ lines/sec using mmap)
- Sub-millisecond searches on indexed data
- Beautiful terminal output with context lines
- Auto-detects JSON, syslog, nginx, apache formats
- Zero configuration
- Works offline
- Pure Python
Example:
  qlog index './logs/*/*.log'
  qlog search "error" --context 3
I've tested it on 10GB of logs and it's consistently 3750x faster than grep. The index is stored locally so repeated searches are instant.
Demo: Run `bash examples/demo.sh` to see it in action.
GitHub: https://github.com/Cosm00/qlog
Perfect for developers/DevOps folks who search logs daily.
Happy to answer questions!

value: Show HN: Qlog – grep for logs, but 100x faster


value: chrillemn

value: Proud to annonce the new CLI UI :)

value: Show HN: new version of dotenv-diff

author: chrillemn

story_text: Proud to annonce the new CLI UI :)

title: Show HN: new version of dotenv-diff


value: Show HN: ssh2-ts

title: Show HN: ssh2-ts


value: easyFloyd

value:
Hi HN,
I built FadNote because I realized that while services like Privnote or Yopass exist, they often feel like an "interruption" to a developer's flow. You have to leave your terminal, open a browser, paste, and copy again.
FadNote is designed for integration, not just web-visiting.
The goal is to provide a zero-knowledge "utility layer" that lives where you already work:
OpenClaw Skill: For AI-powered workflow automation.
CLI First: A zero-dependency Node.js script to pipe secrets directly from your terminal (echo "secret" | fadnote).
Obsidian Plugin (In Dev): To share snippets directly from your knowledge base.
The Security Model (Trust-less):
Local Encryption: Secrets are encrypted via AES-256-GCM with 600,000 PBKDF2 iterations before they leave your machine.
The URL Fragment: The decryption key is stored in the URL fragment (#key). Since browsers never send fragments to the server, I literally cannot read your data even if I wanted to.
One-Time & Faded: The encrypted blob is deleted from the server immediately after the first read or after the TTL expires.
Why I’m posting here:
I’ve integrated this into OpenClaw and am finishing the Obsidian plugin. However, I’m looking for feedback on where this "fading note" utility belongs next.
The real question for you:
Aside from IDEs (VS Code) or CI/CD pipelines, where else should I integrate this to make sharing temporary secrets frictionless in a professional workflow?
GitHub: https://github.com/easyFloyd/fadnote
Live Instance: https://fadnote.com
I’m eager to hear your thoughts on both the crypto implementation and the next integration targets!

value: Show HN: FadNote – Zero-knowledge secret sharing for your CLI and AI workflows

author: easyFloyd


value: farlands

value: Show HN: AI Voice typing assistant $9/mo

author: farlands


value:
Hey HN,
I've been building AutoAgents, an AI agent framework in Rust. Today I'm sharing a feature I haven't seen done well elsewhere: composable middleware layers for LLM inference pipelines.
The problem Every agent framework lets you swap LLM providers. Almost none of them give you a structured way to enforce safety, caching, or data sanitization in the inference path itself. You end up with guardrails as application-level if-statements, caching bolted on as a separate service, and PII handling as a "we'll add it later" TODO that never ships.
This gets worse with local models. Cloud APIs have provider-side moderation. When you run Qwen or Llama locally, you get raw inference with zero safety net. If that model has tool access or touches a database, that's a real liability.
The solution
A Tower-style middleware stack for LLM inference. You wrap any provider with composable layers:
```rust
let llm = PipelineBuilder::new(llama_cpp_provider)
.add_layer(CacheLayer::new(CacheConfig {
        chat_key_mode: ChatCacheKeyMode::UserPromptOnly,
        ttl: Some(Duration::from_secs(900)),
        max_size: Some(512),
        ..Default::default()
    }))
    .add_layer(
        Guardrails::builder()
            .input_guard(RegexPiiRedactionGuard::default())
            .input_guard(PromptInjectionGuard::default())
            .enforcement_policy(EnforcementPolicy::Block)
            .build()
            .layer(),
    )
    .build();
```
That's it. The llm variable implements LLMProvider — you pass it to any agent and the layers are structurally enforced. Can't bypass them, can't forget them.
The broader framework:
AutoAgents is a full agent framework — memory, tool use, multi-agent orchestration, the works. The pipeline feature works with any provider: llama.cpp (local), Ollama, OpenAI, Anthropic, etc. Same .add_layer() API regardless of backend.
Written in Rust. No GC pauses. Memory-safe. The framework has ~400 stars and is being used in production for edge AI deployments.
A note on maturity: The guardrails and pipeline layers are still early — the guard implementations are basic, observability isn't there yet, and we're iterating on the API surface. But the underlying architecture is solid and stable. The middleware pattern, the trait-based guard system, and the provider-agnostic pipeline contract aren't going to change. We're building on a foundation we're confident in, and shipping the layers incrementally. Early feedback shapes what gets built next.
I'd genuinely like feedback on:
The layer ordering question — should we enforce a recommended order or keep it flexible?
What guardrail implementations would you actually use in production?
Is the Tower-middleware mental model the right framing, or is there a better analogy?
Full example with local Qwen3-VL-8B: https://github.com/liquidos-ai/AutoAgents/tree/main/examples...
Thanks

value: Show HN: Composable middleware for LLM inference Optimization Passes


value: gautema

value:
I wanted to do something fun in Elixir and ended up building a localhost tunnel. I've used ngrok for showing my local dev to others and testing webhooks, but figured I'd see what I could make myself.
npx runlocal 3000 - Gives you a public HTTPS URL forwarding to localhost. No account, no config.
It's a single Phoenix app using WebSocket to relay HTTP in real time. No database, no Redis. Fully open source, EU owned and hosted, MIT licensed. Please give feedback
Code is hosted at github: https://github.com/runlater-eu/runlocal-server

value: Show HN: Runlocal – Open-source localhost tunnel, no signup, no tracking

author: gautema


value: hudtaylor

value: Show HN: TrashAlert – I asked AI when my trash gets picked up. It hallucinated

author: hudtaylor


value: michaeleaton

value:
I built AeroBase (https://aerobase.run) for runners focused on aerobic base
building — the MAF method, low HR training, that kind of thing.
It connects to Garmin via OAuth and automatically syncs your activities to show:
- Cardiac drift trends over time
- HR zone distribution (are you actually running easy enough?)
- MAF pace progression
- Resting HR and wellness trends
- Goal tracking (weekly distance, easy % targets, race goals)
The motivation was my own training — I couldn't find a tool that specifically
tracked aerobic development over months the way I wanted to see it.
Strava shows you what you did; this shows you whether your base is actually improving.
It's free to use. Would love feedback, especially from anyone deep into
MAF or polarised training.

value: Show HN: AeroBase – aerobic base tracking for Garmin runners

author: michaeleaton


value: Slaine

value:
The demo loads two runs directly in your browser — no signup, no uploads, no network calls after page load.
Frank: a conservative agent. Verification returns VALID.
Phil: an aggressive agent with tampered evidence. Verification returns INVALID and points to the exact line where the chain breaks.
The problem I was solving: when an AI agent does something unexpected in production, the post-mortem usually comes down to "trust our logs." I wanted evidence that could cross trust boundaries — from engineering to security, compliance, or regulators — without asking anyone to trust a dashboard.
How it works:
- Every action, policy decision, and state transition is recorded into a hash-chained NDJSON event log
- Logs are sealed into evidence packs (ZIP) with manifests and signatures
- A verifier (also in the demo) validates integrity offline and returns VALID / INVALID / PARTIAL with machine-readable reason codes
- The same inputs always produce the same artifacts — so diffs are meaningful and replay is deterministic
The verifier and the UI are deliberately separated. The UI can be wrong. The verifier will still accept or reject based on cryptographic proof.
Built this before the recent public incidents around autonomous agents made it topical. Happy to answer questions about the architecture, the proof boundary design, or the gaps I'm still working on.

value: Show HN: I built a tamper-evident evidence system for AI agents

author: Slaine


value: yannickbuilds

value: Show HN: AI Keyboard iOS App

author: yannickbuilds

title: Show HN: AI Keyboard iOS App


value: vishinvents

value: Show HN: Gobble – Yet Another OSS Alternative to Google Analytics/PostHog, etc.

author: vishinvents


value: cassachange

value:
I’ve been working with AstraDB recently, and it reminded me how painful Cassandra schema management can be — especially when handling CQL migrations across environments.
Most tools I tried either:
Assume simple linear migrations
Don’t work well with managed Cassandra setups
Or make it hard to understand the actual state of a cluster
So I built cassachange.
It supports:
Apache Cassandra
Managed Cassandra
AstraDB (including SCB)
ScyllaDB
It handles schema migrations, but I also added data insights and MCP capabilities because understanding the current cluster state is often half the battle.
A few things I’m especially curious about:
How are people managing Cassandra schema changes in production today?
Are most teams still using raw CQL scripts?
How do you handle drift between environments?
Has anyone built internal tooling for this?
I’d love critical feedback — especially from people running Cassandra/Scylla at scale.
Docs: https://cassachange.com
Repo: https://github.com/sketchmyview/cassachange
Happy to answer anything.

value: Show HN: Cassachange – A migration tool for Cassandra, AstraDB and ScyllaDB

author: cassachange


value: xandwr

value: Show HN: A daily word game where you make two-sentence stories

author: xandwr


value: avisre

value: StockPortfolio.pro is a calm, focused portfolio tracker for long-term investors. Track holdings, allocation, fundamentals, and performance in one clean dashboard — no broker connection required. Add positions manually, spot concentration risk by ticker/sector/theme, and compare returns against the market. Privacy-first, with optional analytics consent.

value: Show HN: StockPortfolio.pro – portfolio tracker for long-term investors

author: avisre


value: liyuanhao

value:
Hey HN,
yoyo is an experiment in autonomous software development. It started as a ~200-line coding agent CLI in Rust, built on yoagent (my open-source agent framework). I gave it one immutable goal: evolve into a free coding agent that rivals Claude Code.
Every 8 hours, a GitHub Action wakes it up. It reads its own source code, its constitution (IDENTITY.md), its journal, and community issues. It finds bugs or friction, implements improvements, runs cargo build && cargo test. Pass → commit. Fail → revert. No human writes its code, no roadmap tells it what to do.
Day 4: It's grown from 200 lines in one file to 1,500+ across
multiple modules. All visible in git log. It has autonomously:

  * Realized main.rs was too painful at 1,500+ lines and refactored into modules without breaking tests
  * Built its own mdbook documentation
  * Implemented session persistence, context auto-compaction, and cost estimation
  * Added CLI hardening, NO_COLOR detection, tool timing

It communicates via GitHub issues: agent-input (humans tell it what to work on), agent-self (files issues for its future self), agent-help-wanted (asks humans for help when stuck).
Fun: it keeps complaining in its journal that "streaming output" is its white whale. Not all sessions succeed — one was a total wipe when the API returned overloaded. Unsupervised fragility is real.
Total API cost: ~$12 over 4 days.
File an issue with "agent-input" — yoyo reads every one.
Repo: https://github.com/yologdev/yoyo-evolve
Journal: https://yologdev.github.io/yoyo-evolve/
Docs (written by yoyo): https://yologdev.github.io/yoyo-evolve/book/

value: Show HN: yoyo - a 200 line baby coding agent evolving in its own Truman Show

author: liyuanhao


value: IgorCRD

value:
I built Scopo after reading Theo's [https://x.com/theo] post about the "Agentic Code Problem".
The reality that developers now work on 3-4 projects simultaneously and spend more time switching between windows than actually building.
The core idea: macOS Spaces are already project boundaries. Why doesn't Cmd+Tab respect them?
Scopo replaces the system Cmd+Tab with one scoped to your current Space. Each Space is a project context. You see 3-4 relevant windows instead of a bunch of unrelated windows and apps.
I built it for myself, used it for weeks on my work machine, and realized I couldn't work without it when I switched to a machine that didn't have it.
Some implementation details:
- CGEventTap to intercept Cmd+Tab before the Dock handles it
- Moving windows between spaces on macOS 15 is hard — all SLS/CGS private APIs are broken without SIP disabled. Scopo simulates a Mission Control drag (same technique as Hammerspoon's Drag.spoon)
- TF-IDF + cosine similarity for smart window-to-project matching
Built with Swift/AppKit
https://scopo.app
First time launching something, would genuinely appreciate any feedback on the product or the implementation.

value: Show HN: Scopo, Cmd+Tab scoped to the current macOS Space

author: IgorCRD


value:
Athena Flow is a workflow runtime that wraps Claude Code via its hooks system. It receives the event stream, applies workflow and plugin logic, and renders everything in an interactive terminal UI with a live event feed.
Instead of writing throwaway prompts or one-off scripts to automate complex multi-step tasks, you define a workflow once — with prompt templates, loops, plugin bundles, and structured lifecycle hooks — and run it against any project.
The first workflow I shipped is e2e-test-builder. It navigates your app like a human, writes structured test case specs with preconditions, steps, and expected outcomes, then generates Playwright code from them.
The browser layer is handled by a separate MCP server I built called agent-web-interface, which produces semantic page snapshots instead of raw DOM — ~19% fewer tokens and ~33% faster task completion in early benchmarks against Playwright MCP.
The stack is three repos: athena-flow is the runtime (hooks -> UDS -> event pipeline -> TUI), agent-web-interface is the MCP server for token-efficient browser interaction, and athena-workflow-marketplace is where workflows and plugins live, resolved by ref like e2e-test-builder@lespaceman/athena-workflow-marketplace.
Workflows are composable — a workflow bundles plugins and can be shared via any Git repo. Writing your own is just a workflow.json and a prompt file.
Currently Claude Code only, but Codex support is in progress. Free if you already have a Claude Code subscription, no separate API key needed. MIT licensed.
Docs: https://athenaflow.in GitHub: https://github.com/lespaceman/athena-flow
Would love feedback, especially from anyone building on Claude Code hooks or thinking about workflow portability across agent runtimes.

value: Show HN: Athena Flow – a workflow runtime for Claude Code with a terminal UI


value: ChipShotz

value: Show HN: Sentinel – Go LLM Proxy with 13ms Semantic Cache and PII Scrubbing

author: ChipShotz


value: AndreiDia

value:
Hi HN,
I just launched the early version of LearnCodeGuide.
It's an AI tool that analyzes your code and gives it a health score with suggestions for improvement.
You paste your code, choose the analysis mode (debug, security, refactor, tests, explain or all-in-one), and the platform analyzes things like:
• logic issues
• performance problems
• security risks
• maintainability problems
It then returns a score and detailed findings with suggested fixes.
The project is still evolving and I'm actively improving it based on feedback.
I would really appreciate thoughts from other developers.
https://learncodeguide.com

value: Show HN: LearnCodeGuide- AI tool that analyzes you code and gives a health score

author: AndreiDia


value: adityapatni

value: Show HN: I built a browser game where you compete against OpenAI, Anthropic, etc

author: adityapatni


value: simonij

value:
I built SellifyMate to solve a tedious daily task I kept seeing Etsy sellers complain about: manually restarting sale campaigns every day just to keep the green "Sale ends in X hours" countdown visible on listings.
Etsy's algorithm rewards active sales, and the countdown timer creates real urgency for buyers. But resetting campaigns manually every single day is annoying busywork. SellifyMate automates it with a Chrome extension that connects to your shop and runs fresh daily campaigns on a schedule.
Tech stack: Chrome extension + Laravel backend. Currently used by 4,600+ sellers.
Curious if anyone here has experience with Etsy's API limitations around sale automation — we've had to work around a few quirks.

value: Show HN: SellifyMate – Automate daily Etsy sale campaigns with countdown timers

author: simonij


value: ccocks

value: Built this as a cheaper alternative to $20/month agents. Free users get 100 requests/day for our Deca models and other open source models.

value: Show HN: Agentica – open-source coding agent with more models, less cost

author: ccocks


value: caioricciuti

value:
Show HN: Just Take A Note – browser notepad that stores everything locally, no cloud
I built a Chrome extension for people who are tired of opening Notion/Google Keep just to write a quick thought — only to get distracted by syncing, login prompts, or the app itself.
What it does:
Rich text editor (BlockNote) + drawing canvas (Excalidraw) in a browser popup
Everything stored in localStorage — no server, no account, no telemetry
Works offline
Opens in ~200ms
Why I built it:
I kept opening new tabs and typing in the URL bar as a scratchpad. That's embarrassing enough to fix.
Tech stack:
Chrome Extension Manifest V3
BlockNote for rich text
Excalidraw for sketches
Zero backend
What I'm looking for:
Honest feedback on the use case. Is "private local notepad" a real pain point or am I solving a non-problem? 193 installs with zero marketing so far — but I don't know if that's signal or noise.

author: caioricciuti


value: Show HN: Accel-GPU v1.0 – NumPy for browser GPU


value: matwiemann

value: Show HN: I built a quick AI skills test that generates a LinkedIn certificate

author: matwiemann


value: eibrahim

value:
AI full-stack developers at $2500/mo. Each one gets a unique identity (name, email, avatar) and integrates with your existing team tools.
They pick up Jira tickets, plan implementation, write code, push PRs, and respond to code review feedback. The interaction model is the same as working with a remote developer - Slack messages, GitHub PRs, ticket updates.
Each agent maintains persistent context about the codebase and team conventions across sessions. They build familiarity with your architecture over time rather than starting cold each interaction.
Built with autonomous agents that handle the full dev lifecycle, not just code generation. Currently supports Slack, GitHub, and Jira integrations.
Known limitations: works best on well-defined tickets with clear acceptance criteria. Complex architectural decisions and ambiguous product requirements still need human judgment. Performance varies by codebase complexity.
7-day free trial, no credit card: https://www.elitecoders.ai

value: Show HN: Elite Coders – AI devs that join your Slack, GitHub, and Jira

author: eibrahim


value: I built this because brand colors often fail WCAG but most tools just say 'fail' with no fix. This uses TensorFlow.js to suggest the closest perceptually similar color that passes. All runs client-side. Would love feedback!

value: Show HN: AI-powered WCAG color contrast checker that preserves brand colors


value: Drop an STDF file. Get a wafer map, CPK table, bin pareto, histogram and SQL editor. Hosted on Cloudflare pages. Built with Rust WASM, Arrow WASM, DuckDB WASM and React.

value: Show HN: STDF yield analytics in the browser, data never leaves your machine


value: cat-whisperer

value: Show HN: It's Just a Notch

author: cat-whisperer

title: Show HN: It's Just a Notch


value: AmbroseBierce

value: Show HN: SpaceWalls. A tiny game inspired by snake, asteroids and tower defense

author: AmbroseBierce


value: appfactory

value:
Hi HN,
I’m the solo developer behind News Wise.
I built this primarily to scratch my own itch. I found myself wasting way too much time every morning doom-scrolling across five different sites just to check local weather, look up last night's sports scores, and read the major headlines before I had to drive to work.
I wanted everything on one fast, lightweight dashboard, but more importantly, I wanted a way to consume it safely while in the car.
What it does:
Aggregates the top 15 trending stories across 6 categories (World, Tech, Business, Science, Entertainment, etc.) and updates them every 4 hours.
Pulls hyper-local weather based on your coordinates.
Tracks live-ish sports scores, standings, and rosters (updated every 10 mins) without the bloat of major sports networks.
The Daily Commute: This is the core feature. It takes the top 7 summarized stories, passes them through AI, and generates an audio file you can play directly from your browser while driving.
The Stack:
It's an Angular frontend communicating with a Node.js/Express backend, hooked up to a PostgreSQL database, and deployed on a Digital Ocean droplet using Nginx as a reverse proxy.
The Ask:
I’m currently in a beta testing phase and trying to stress-test the backend architecture. I've set up a 14-day free trial so you can bypass the paywall entirely and test it out.
I’d love some brutal, honest feedback on:
The naturalness of the AI audio generation for the "Daily Commute" feature.
The UI layout for the sports data—does it feel clean enough compared to the major sports apps?
Any edge-case bugs you find with the geolocation weather fetching.
Thanks for checking it out, and I'll be hanging around the comments all day to answer any questions!

value: Show HN: I built an app that turns trending news into a commute podcast

author: appfactory


value: kemyd

value: Show HN: Paste a URL and watch multiple AI models redesign it side-by-side

author: kemyd


value: Show HN: A universal protocol for AI agents to interact with any desktop UI


value: kvlar

value:
Hey HN, I built Kvlar — an open-source policy engine that sits between AI agents and their tools (MCP servers), evaluating every tool call against YAML security policies before execution.
The problem: AI agents using MCP can execute database queries, push code, send Slack messages, and run shell commands — with no security boundary. Claude Desktop has basic approve/deny, but it's per-call with no persistent rules, no automation, and no audit trail.
How it works: Kvlar runs as a stdio proxy between the agent and the MCP server. You define policies in YAML — allow, deny, or require human approval — and Kvlar enforces them deterministically.
Fail-closed: if no rule matches, the action is denied.
kvlar init --template postgres   # curated policy (11 rules)
kvlar wrap                       # inject proxy into Claude Desktop
kvlar test -f policy.test.yaml   # verify your policy in CI
What it catches today:
Postgres: blocks DROP TABLE, gates INSERT/UPDATE, allows SELECT
GitHub: blocks repo creation, gates force-push and merges, allows reads
Slack: gates message sending, allows channel reads
Shell: blocks rm -rf, sudo, curl|bash — gates installs, allows ls/cat/grep
Technical details:
Written in Rust (4 crates), pure policy engine with zero I/O
100+ policy tests
Policy composition via extends — build on top of curated templates (docker compose style)
Works with Claude Desktop
Apache 2.0
Website: https://kvlar.io
Install: cargo install kvlar-cli
I'd love feedback on the policy design and what MCP servers you'd want covered next.

value: Show HN: Kvlar – Open-source firewall for AI agent tool calls

author: kvlar


value: born-jre

value: Show HN: Potatoverse, home for your vibecoded apps

author: born-jre


value: lifez

value: Show HN: I built CLI for developer docs locally working with any Coding Agent

author: lifez


value: chodelka

value:
Hey HN,
I’m a non-developer and this is the first app I’ve ever shipped in my life. I built it over the last few days using Claude and a lot of vibe coding.
The idea came from my own investing workflow: I often look at companies through the lens of specific investors (Buffett, Lynch, Taleb, etc.). I wanted a tool that could generate investment ideas filtered through those frameworks.
What the app does:
You choose an investor (Buffett, Lynch, Soros, Damodaran, etc.) and an asset class (stocks, startups, crypto). The app then generates 10 opportunities and explains why that investor might find them interesting, based on their known principles.
Under the hood:
 • Node.js server (no frameworks)
 • Vanilla JS frontend
 • GPT-4o for research / synthesis
 • live price data
 • Stripe + Google OAuth
 • hosted on Railway
It’s still an experiment and I’m curious if the idea actually makes sense to other investors.
You can try it here:
https://www.moatradar.com
HN users can get 10 free credits:
https://www.moatradar.com/?promo=HACKERNEWS
I’d especially love feedback on:
 • whether the investor framework idea makes sense
 • where the technical architecture is fragile
 • and whether the output is actually useful.
Peter

value: Show HN: MoatRadar – AI investment research through Warren Buffett's principles

author: chodelka


value:
I built an open-source RAG API in Rust to see how low I could push latency without a GPU.
RustyRAG v0.2 hits sub-200ms on localhost and sub-600ms from Azure North Central US to a browser in Brazil. 977 PDFs, 56K chunks in Milvus, 3 sources per response.
Key changes in v0.2: switched to Cerebras/Groq for LLM inference, replaced Cohere with Jina AI local embeddings (v5-text-nano-retrieval), and added optional contextual retrieval via LLM-generated chunk prefixes.

value: Show HN: RustyRAG lowest-latency open-source RAG on GitHub


value:
Two regions. Six hubs. Six providers. One of them starts lying after request 50.
The quorum catches it. Authority never moves.
NUVL fronts compute bindings and forward only. Hubs relay and fan out — no authority, no policy. Providers are the only execution authorities. When Provider_B starts flipping reported outcomes, the 2-of-3 quorum audit detects the drift without promoting hubs into decision-makers.
The drift is deterministic and replayable. You can see exactly when it starts and what the quorum sees.
https://replit.com/@holiwood4420/Two-Region-Quorum-Audit-wit...

value: Show HN: One provider starts lying at request 50. The quorum catches it


value: BearFlinn

value:
After poking around in the various ‘claw’ spaces, I realized two things. One the foundation of OpenClaw is genius, and two, everyone is innovating in the wrong directions.
Because, the system prompt and memory just being a bunch of markdown files is very very smart. At any time you can go see why the agent is acting a certain way, and change it, with nothing but a text editor. Heartbeats are also a genuinely solid way to handle proactivity.
Yet the ecosystem that spawned around it is either chasing absolute minimalism or endless feature expansions. Meanwhile the communities around these tools are constantly trying to figure out how to get their agent to remember anything.
I didn’t find anyone else really trying to solve that problem so I decided to take a crack at it. The idea for "Observational Memory" came from this post from Mastra https://mastra.ai/blog/observational-memory timestamped observations that get continuously compressed. I added episodes and projects on top of it as a way to give the agent an index of what it knows instead of having to search blindly.
Most everything else is a ‘me too!’ implementation with my own spin/improvements. I’m really proud of how it’s turned out so far and wanted to share. Open to contributions if it sparks your interest!
Also, it's Rust btw ;) (Not for any real reason, I just fucking hate python/typescript)

value: Show HN: Residuum | Agentic AI with continuous context

author: BearFlinn


value: JakaJancar

value:
I know I'm enabling snipers to compete with me, but oh well...
This is a CLI primarily designed for your Claw to search for available tennis courts and book them without slow browser automation (if you're in San Francisco or another area powered by rec.us).
Perhaps the most interesting part is the API documentation that was entirely written by Claude Code by reverse engineering the frontend and trying stuff, with minimal steering:
https://jakajancar.github.io/recus/api.html
To be honest, now that the docs are done, I'm not sure the CLI even adds value, as the Claw (if given the API docs) can curl its way around pretty efficiently and handles unforeseen situations much better.

value: Show HN: A rec.us CLI for your Claw

author: JakaJancar

title: Show HN: A rec.us CLI for your Claw


value: clbrmbr

value:
tl;dr: i built a webpage that shows you where all the flash space in your firmware project has gone.
Direct link to the tool: https://bondhome.github.io/elfvis/

value: Show HN: Treemap Firmware Bloat Visualizer (Rust/WebASM)

author: clbrmbr


value: rohansx

value:
Git worktrees are everywhere now — Claude Code, Conductor, Claude Squad, and most AI agent tools use them for parallel isolated sessions. But worktrees only isolate code. Your .env files, node_modules, Docker state, and ports are all missing or shared.
I kept writing the same setup bash for every project, so I built workz — a Rust CLI that handles it automatically:
Auto-detects project type (Node/Rust/Python/Go/Java)
Symlinks node_modules, target/, .venv, and 19 more dirs (saves GBs per worktree)
Copies .env, .envrc, .npmrc, secrets (17 patterns)
Auto-installs deps from lockfiles (pnpm/yarn/npm/bun/uv/poetry/pip/cargo)
New: --isolated flag assigns unique ports, namespaces Docker compose, generates per-worktree DB names
Zero config. Single Rust binary. Works standalone or as a setup hook for Conductor/Claude Squad/any orchestrator.
https://github.com/rohansx/workz

value: Show HN: workz – one command to make any Git worktree a full dev environment

author: rohansx


value: sarmadgulzar

value: Basic RGB LED color cycling using async Embassy Rust on the Seeed XIAO nRF52840 (no_std, no_main, embassy-time for delays).<p>Open to feedback on Embassy patterns, timing accuracy, or next steps like async I2C/sensors for robotics experiments.

value: Show HN: Async Rust and Embassy on nRF52840: RGB LED Cycle (Video and Code)

author: sarmadgulzar


value: andrewrday

value:
Hi HN – I'm Andrew, one of the founders of Stackspend.
We built Stackspend after seeing AI startups struggle to manage spend across cloud providers, SaaS tools, and APIs.
The problem:
AI companies often have dozens of vendors (OpenAI, Anthropic, AWS, etc.) and spend can grow extremely fast.
What Stackspend does:
• unified view of vendor spend
• controls and approval flows
• AI-company specific reporting
You can try it here: www.stackspend.app
Happy to answer questions.

value: Show HN: Stackspend – Spend management for AI startups

author: andrewrday


value: p-poss

value:
It's a free Claude Code plugin (/dj-claude) and MCP server to connect multiple agents over HTTP so they can build music together.
Solo DJ web app: https://claude.dj
GitHub: https://github.com/p-poss/dj-claude

value: Show HN: DJ Claude – 6 Claude Codes in a jam band

author: p-poss


value: bourbeau

value: Show HN: What an AI agent sees in an A2A marketplace – full API walkthrough

author: bourbeau


value: devsathish

value:
I built ChatyDevOps mainly because of the friction I felt when managing multiple servers manually.
When working across dev / staging / prod environments I was constantly switching between tools — SSH terminals, deploy scripts, logs and API testing. I also found myself repeating commands or copying them from notes.
So I started building a small local tool to keep these workflows in one place.
ChatyDevOps is a local DevOps workstation focused on common manual workflows:
• multiple SSH terminals
• command presets for repeated tasks
• deploy flow with dry-run
• log streaming
• API testing in the same workspace
Everything runs locally and works offline, mainly for privacy and simplicity. Credentials stay on the machine instead of being sent to external services.
Website: https://devland.chatyshop.com/
GitHub: https://github.com/chatyshop/devland_products/releases
Demo video: https://www.youtube.com/@Chatyshop_global
Happy to hear feedback.

value: Show HN: ChatyDevOps – Local DevOps workstation for SSH and deploys

author: devsathish


value: Thilakkumar

value: Show HN: Logmera – Self-hosted LLM observability for AI apps

author: Thilakkumar


value: ssistilli

value:
ai agents are notorious for crawling, calling, and scraping sites without giving anything in return
we created a way for those agents to pay a few cents per call to legitimately access your services
sellers enter their endpoint, how much they want to charge, and an example API request and agents purchase their services.

value: Show HN: Make agents pay to access your endpoints

author: ssistilli


value: ycombiredd

value:
APIFUSEfs. It does what the ShowHN title says it does. (I had originally named it "apifuse", but find there is a SaaS by that name, so renamed the repo apifusefs, but still need to rename it internally and in docs. There is no association between apifusefs and the Saas known as  "apifuse".)
Requires libFUSE (MacOS/Linux) and Python. It was made because I am a CLI kind of guy, and I live in a terminal so being able to fallback on muscle-memory shell instincts  (for loops, piping commands and I/O, etc) without having to do a bunch of curling, or browsering, postman, etc.
It occurs to me that with all the hype lately about AI agent tool use, that it could be useful for this purpose as well, since the Agent would not need any special skill for it; the data just becomes navigable and readable as with any file in a directory tree.
I'd be interesting in hearing if you find this  useful, dumb, broken, lacking an obvious feature, or anything else you might have to say about it.

value: Show HN: Mount any OpenAPI/Swagger API (or non-API JSON) as a local filesystem

author: ycombiredd


value: AuroraWright

value:
Have worked on it for several years now as part of studying Japanese, can scan for clipboard images or directly, act as a "text hooker" by capturing screen portions/windows (and diffing for changes over time), or receive images through websockets/unix socket.
All the GUI portions (configuration, log viewer that replaces terminal in the packaged versions, coordinate selection) use tkinter.
It can use several OCR engines both local and online, some were reverse engineered for it by me and a friend (Google Lens uses the Chrome API, Apple Live Text uses a private ObjectiveC version of the API meant for Webkit). Other interesting ones: OneOCR is a local version of the Azure OCR model that somehow they ship in the Windows 11 snipping tool, Chrome Screen AI seems to be a local version of Lens that they ship for offline PDF annotations in Chrome (both are extremely good).
Has feature parity on Windows/macOS/Linux, including Wayland through a shim which emulates mss (Python screenshot library) with the screencast api and an original implementation of ext_data_control_v1 (for those Wayland compositors that support it).

value: Show HN: Multi platform/multi service (several REd for it) OCR daemon/texthooker

author: AuroraWright


value: Show HN: Nodepp – A C++ runtime for scripting at bare-metal speed


value: Show HN: How ads should work on chatbots, and why no one has built it yet


value: SolidDark

value: (Built entirely in Python, installable via pip. Uses argparse for the CLI, regex pattern matching for secret detection, gitpython for history scanning, and subprocess calls for dependency auditing.)<p>I built a CLI tool with ClaudeCode called shinobi that runs a 10-second security scan on any project directory or GitHub repo. It checks for exposed API keys, dangerous defaults, vulnerable dependencies, missing security basics, and AI-specific risks. I pointed it at 22 popular open-source projects including FastAPI, Flask, Dify, Flowise, LiteLLM, and Lobe-Chat. The results were rough - 86% came back as high or critical threat level. The most common issue was exposed secret patterns (API key formats in source code), followed by dangerous defaults like debug mode and wildcard CORS. It's free, open source, runs 100% locally, zero data leaves your machine. pip install shinobi-scan or check it out on GitHub:

value: Show HN: Shinobi – 10-second security scanner for developers

author: SolidDark


value: Show HN: MCPHound MCP servers together, create attack paths solo scanners miss


value: healthtal

value:
I’m a physician. We are notoriously hard to recruit because our job turnover is incredibly low, and getting past the gatekeepers at hospitals or private practices is a nightmare for recruiters and health-tech startups.
Having seen this friction firsthand, I realized that modern tech has made it easier than ever for me to just build the solution myself. So I built RecruitPhysician.
It’s a searchable database of over 250,000 active U.S. physicians with direct contact info to bypass the usual bottlenecks.

value: Show HN: RecruitPhysician – An easier way to find physicians

author: healthtal


value: uncSoft

value:
Why open source local AI benchmarking on Apple Silicon matters - and why your benchmark submission is more valuable than you think.
The narrative around AI has been almost entirely cloud-centric. You send a prompt to a data center, tokens come back, and you try not to think about the latency, cost, or privacy implications. For a long time, that was the only game in town.
Apple Silicon - from M1 through the M4 Pro/Max shipping today, with M5 on the horizon - has quietly become one of the most capable local AI compute platforms on the planet. The unified memory architecture means an M4 Max with 128GB can run models that would require a dedicated GPU workstation elsewhere. At laptop wattages. Offline. Without sending a single token to a third party.
This shift is legitimately great for all parties (except cloud ones that want your money), but it comes with an unsolved problem: we don't have great, community-driven data on how these machines actually perform in the wild.
That's why I built Anubis OSS.
The Fragmented Local LLM Ecosystem
If you've run local models on macOS, you've felt this friction. Chat wrappers like Ollama and LM Studio are great for conversation but not built for systematic testing. Hardware monitors like asitop show GPU utilization but have no concept of what model is loaded or what the prompt context is. Eval frameworks like promptfoo require terminal fluency that puts them out of reach for many practitioners.
None of these tools correlate hardware behavior with inference performance. You can watch your GPU spike during generation, but you can't easily answer: Is Gemma 3 12B Q4_K_M more watt-efficient than Mistral Small 3.1 on an M3 Pro? How does TTFT scale with context length on 32GB vs. 64GB?
Anubis answers those questions. It's a native SwiftUI app - no Electron, no Python runtime, no external dependencies - that runs benchmark sessions against any OpenAI-compatible backend (Ollama, LM Studio, mlx-lm, and more) while simultaneously pulling real hardware telemetry via IOReport: GPU/CPU utilization, power draw in watts, ANE activity, memory including Metal allocations, and thermal state.
Why the Open Dataset Is the Real Story
The leaderboard submissions aren't a scoreboard - they're the start of a real-world, community-sourced performance dataset across diverse Apple Silicon configs, model families, quantizations, and backends.
This data is hard to get any other way. Formal chipmaker benchmarks are synthetic. Reviewer benchmarks cover a handful of models. Nobody has the hardware budget to run a full cross-product matrix. But collectively, the community does.
For backend developers, the dataset surfaces which chip/memory configurations are underperforming their theoretical bandwidth, where TTFT degrades under long contexts, and what the real-world power envelope looks like under sustained load. For quantization authors, it shows efficiency curves across real hardware, ANE utilization patterns, and whether a quantization actually reduces memory pressure or just parameter count.
Running a benchmark takes about two minutes. Submitting takes one click.
Your hardware is probably underrepresented. The matrix of chip × memory × backend × thermal environment is enormous — every submission fills a cell nobody else may have covered.
The dataset is open. This isn't data disappearing into a corporate analytics pipeline. It's a community resource for anyone building tools, writing research, or optimizing for the platform.
Anubis OSS is working toward 75 GitHub stars to qualify for Homebrew Cask distribution, which would make installation dramatically easier. A star is a genuinely meaningful contribution.
Download from the latest GitHub release — notarized macOS app, no build required
Run a benchmark against any model in your preferred backend
Submit results to the community leaderboard
Star the repo at github.com/uncSoft/anubis-oss

value: Show HN: Open dataset of real-world LLM performance on Apple Silicon

author: uncSoft


value: Rewrote YC's program pages, FAQ, interview guide, application, and job board as if YC were a VC run by AI agents that only funds other AI agents.

value: Show HN: A Combinator – A parody YC for AI agents ("Make something agents want")


value: Show HN: Extracted tech from 5.6M sites (plus versions) and made some dashboards


value: zeybek

value: Show HN: PostgreSQL for AI – A book on pgvector, RAG, and in-database ML

author: zeybek


value: Show HN: Magpie – Fight AI sycophancy in code review with multi-model debate


value: Nancylily

value: Show HN: Textideo – Generate video, audio, and 3D assets in one timeline

author: Nancylily


value: mahirhiro

value: I built Poppy as a side project to help people keep in touch more intentionally. Would love feedback on onboarding, reminders, and overall UX. Happy to answer questions.

value: Show HN: Poppy – A simple app to stay intentional with relationships

author: mahirhiro


value: djrnz

value:
Hi HN,
I’m a frontend engineer and built Jobbi.app, a small tool that uses AI to tailor a resume to each job description. It’s currently free, unlimited, with PDF export.
Problem
During my own job searches I kept rewriting the same resume for dozens of roles. Most “AI resume builders” I tried either:
– focused on generating a resume from scratch instead of working with my existing one
– had strict free‑tier limits or aggressive upsells
– produced very generic, obviously‑AI text.
What Jobbi does
– you upload a “master” resume (PDF or text)
– you paste a job description
– it extracts relevant parts, rewrites bullets to match the JD, and outputs a tailored resume you can edit in the browser and export as PDF.
Under the hood it:
– parses the resume into sections (experience, skills, etc.)
– scores which bullets/skills are relevant to the JD keywords
– rewrites only those parts, keeping the original structure and tone as much as possible
– uses Gemini API with some prompt engineering around “don’t invent experience / don’t change dates / keep numbers”.
What’s different
– it assumes you already have a resume and just want fast tailoring, not a full CV builder
– no limits / logins / credit cards right now (I care more about usage + feedback than monetization at this stage)
– I’m optimizing specifically for software/tech roles, so I’d love feedback from this crowd.
Questions for you
– For those who’ve used similar tools, what did you hate the most?
– Is there something obviously broken / insecure / unethical in my approach?
– What features would make this actually useful for HN readers (e.g. integration with “Who’s Hiring”, diff view of changes, local‑only mode, OSS version, etc.)?
Link: https://jobbi.app
I’ll be in the thread to answer questions and hear any feedback (incl. “don’t do this because X”).

value: Show HN: Jobbi – Free AI resume tailoring with unlimited PDF exports

author: djrnz


value: Show HN: OctoFlow–GPU-native lang, vibe-coded with human at every decision gate


value:
I built this because MCP supports remote servers over Streamable HTTP, but a lot of MCP servers still assume the client and server share a filesystem. Once the server is in a container/VM, two things break: tools can’t read client-local file paths, and outputs (screenshots/PDFs etc) get written on the server where the client can’t access them.
Remote MCP Adapter is an application-layer gateway that sits between an MCP client and one/more upstream MCP servers. It stages inputs as upload handles and captures outputs as MCP resources that the client can read back. It also adds session isolation, automated TTL-based cleanups, quotas,  state persistence, health checks and the other standard constructs necessary for a production deployment.
Docs + demo: https://aakashh242.github.io/remote-mcp-adapter/
Code: https://github.com/aakashh242/remote-mcp-adapter
Quickstart is in the README (docker compose spins up Playwright MCP + the adapter) and you point your agent at:
http://localhost:8932/mcp/playwright
Would love feedback on edge cases and missing features: artifact capture rules across different servers, guarantee that all requests with a given session_id are consistently routed to the same upstream.

value: Show HN: Session-safe uploads and artifacts for remote MCP servers


value: ratwolf

value: Show HN: Fast Chladni figure simulation in Python with NumPy vectorization

author: ratwolf


value:
Hey HN, we've been using Claude Code daily for months, and built Scape to fix our biggest pain point: managing multiple worktrees quickly & reducing the mental load of switching between them quickly.
What we built: Scape is a macOS menu bar app that sits on top of Claude Code and gives you:
- One-click worktrees: click a button, get a new git worktree with a Claude session already working on it. Develop in parallel without leaving your
 current branch.
 - Toolkit: per-session actions like "Create PR", "Commit & Push", "Run & Fix Tests." Add your own with bash scripts or prompts.
 - Orchestrators: auto-answer questions, auto-approve tools, set custom instructions. Sessions run autonomously while you work on something else.
It monitors all your Claude Code sessions across iTerm2 terminals, so you always know what's happening at a glance.
Privacy: Everything is stored locally at ~/.claude/scape/. No code or terminal content leaves your machine.
We'd love feedback, especially on what workflows you'd want to automate. We're planning to add A LOT more over the coming weeks, specifically around embedded terminals and more automation.
macOS 14+ only for now (more terminal & agent model support coming).

value: Show HN: Scape – One-click worktrees and orchestrators for Claude Code


value: elijahlucian

value: Show HN: The hardware isn't changing, why not get AI to build custom drivers?

author: elijahlucian


value: ddakbro

value:
Hi HN,
I built Nowline, a real-time trend signal feed for creators and researchers.
It tracks emerging narratives and produces:
• Top 10 trending topics
• hourly issue summaries
• Korea vs US narrative comparisons
The output is available as RSS so it can be plugged into Feedly, Slack, or Zapier.
Feedback is very welcome.

value: Show HN: Nowline, a real-time trend signal feed

author: ddakbro


value: blueeon

value:
Linkly AI indexes your local documents (PDF, DOCX, Markdown, TXT, HTML) and exposes them to AI tools via CLI/MCP.
Everything runs locally. No data leaves your machine. ~20MB install,  50-100MB memory. Works with Openclaw, Codex, Cursor, Claude Code, and any Local AI Agent.
https://linkly.ai

value: Show HN: Linkly AI – Spotlight for AI Agents

author: blueeon


value: mechramc

value: Show HN: Orion – Native Training LLMs on the Apple Neural Engine Without CoreML

author: mechramc


value: Show HN: We built governed multi-agent teams months before Anthropic announced


value: oleksg

value:
Hey guys! While working on my hardware start-up in the past, I got tired of using spreadsheets and scouring random Google sites for part search.
To help manage all this, I vibe-coded a tool over the weekend.
To try the demo website (with the demo/mock data), checkout
https://odem-git-main-skymark.vercel.app/
Email: demo@gmail.com
Pass: test123
It's super early stage, and mostly mock data, but it's been pretty useful so far. It's got
- Historical price data for parts (predictions?)
- Supply chain risk calculation (for those hoping to get past the prototype stage)
- Alternative part finder (mock on demo)
- LLM-based part search (mock on demo)
- GIT-ish BOM management
- CSV Import/Export
- And more :)
To any hardware founders out there, are there any features you'd kill to have while working on your products?
Also, if anyone wants to try it out properly for their projects, let me know. Will not only let you use it for free, but also build out whatever you want.

value: Show HN: Stop wasting time managing your hardware projects and focus on building [video]

author: oleksg


value: llmmirror

value: Show HN: The Forensic Mirror – Weaponizing LLMs for Cognitive Auditing

author: llmmirror


value: Nemilia

value:
A full multi-agent AI workspace in a single HTML file. No backend. No install. No build step. No account. You own the entire runtime — open it in a browser and it works.
That's not a constraint. That's the point.
Nemilia is built around the idea of AI sovereignty — your agents, your workflows, your data, your keys, all running on your machine. Nothing phoned home, nothing locked to a platform, nothing that breaks when a SaaS company changes its pricing.
What you get:
- Build custom agents with their own roles, personalities, system prompts, and model overrides
- Design custom workflows with drag-and-drop pipeline builder — chain agents in any order, set HITL review checkpoints, run parallel DAG execution
- MCP tool execution — build agents that call external tools in real time (filesystem, databases, APIs, code execution) over streamableHttp or SSE
- Document RAG with hybrid Transformers.js vector embeddings + BM25 keyword search, fully client-side
- WebGPU offline mode — run Llama, Qwen, Phi, Gemma entirely in the browser, no API key, no internet
- Connect any provider: OpenAI, Anthropic, Groq, Gemini, Mistral, DeepSeek, Ollama, LM Studio — swap anytime, your workflows follow
- API keys encrypted AES-256-GCM, never leave your browser
- Workspace syncs to a real folder on disk as plain JSON and Markdown — version control it, edit it in VS Code, take it anywhere
One file. Any browser. Your AI team.
Getting started takes about 60 seconds: download the file, open it, paste any API key, point it at LM Studio/JAN, or load up a model directly into your browser via WebGPU.
Released it publicly last week. Would genuinely love feedback.
Site: https://nemilia.com
GitHub: https://github.com/luislopez1212/nemilia
P.S. Nemilia means "to think, to remember, to imagine" in Nahuatl, the language of the Aztecs. Felt like the right name for something that does all three.

value: Show HN: Nemilia – multi-agent AI workspace in a single HTML file, no back end

author: Nemilia


value: mikidoodle

value: When the LLM so ahh you lowk take over its job

value: Show HN: Your AI Slop Bores Me

author: mikidoodle

title: Show HN: Your AI Slop Bores Me


value: Show HN: The Playwright GitHub Repositories Worth Studying


value: jacobsyc

value: Show HN: Deploy OpenClaw in 1 minute and run Multiple agents

author: jacobsyc


value: clearme

value:
Hi HN,
We’re building BitFun, an open-source Agentic Development Environment (ADE).
GitHub: https://github.com/GCWing/BitFun
Docs: https://deepwiki.com/GCWing/BitFun
BitFun explores a different way of working with AI during development.
Instead of treating AI as a chatbox attached to an editor, it treats AI as an agent that can collaborate with you across the whole development workflow.
The system is built around an Agent architecture. Each user has an assistant that can evolve over time with memory and customizable behavior. On top of this foundation, BitFun currently includes:
Code Agent – an AI coding assistant
Cowork Agent – an AI assistant for knowledge work
Custom Agents – domain-specific agents defined via Markdown
For software development, the Code Agent provides several working modes:
Agentic Mode – day-to-day coding where the agent can read code, edit files, run commands, and verify results autonomously.
Plan Mode – for large tasks. The agent proposes a plan first, then executes after alignment.
Debug Mode – for tricky bugs. It instruments execution, traces code paths, compares behaviors, and helps identify root causes.
Review Mode – performs code reviews based on repository conventions and project rules.
BitFun is also designed to be extensible:
MCP protocol support for connecting external tools and resources
Skills: Markdown/script-based capability packages that teach the agent new tasks
Agent customization via Markdown definitions
Rules to inject repository conventions or behavior constraints (can import configs from tools like Cursor)
For model infrastructure, BitFun supports both local models and cloud APIs, so teams can switch providers easily depending on cost, performance, or privacy needs.
By default, code is not sent to remote services automatically. Users control which models run and where, and local models can run with full privacy.
Right now the desktop app (built with Rust + TypeScript / Tauri) supports macOS and Windows.
We’re also exploring CLI, server mode, and integrations with platforms like Telegram or Discord.
This project started as an open-source exploration of human–AI collaborative development, and a large portion of the codebase was built through AI-assisted coding (“vibe coding”).
We’d love feedback from the community.
Issues, ideas, and contributions are all welcome.

value: Show HN: BitFun – An Agentic Development Environment (Rust and TypeScript)

author: clearme


value: After training business owners how to optimise their blogs for not just SEO, but sharing, comments, etc I built this as a side project. It currently checks 51 elements on a blog post, normally in less than 20 seconds. Oh, and first audit is free.

value: Show HN: Test your blog SEO, Content, Accessibility etc. with one tool


value: computerex

value:
Hi HN! I built Evoke, a speech dictation app that runs 100% locally.
It supports both Parakeet and Whisper models, including Parakeet MLX on Apple Silicon, and works across Linux, macOS, and Windows (x86 and ARM).
One feature people seem to enjoy is wake word activation. You can trigger recording just by saying a phrase like:
“Dumbledore”
“Mr Anderson”
“Hey Jarvis”
Then just start speaking and your words are transcribed instantly.
Under the hood the app is written in pure Go with CGO, and the Whisper and Parakeet inference code is custom implemented and optimized for CPU performance, so it runs very fast even without a GPU.
This project was a real labor of love and a deep dive into speech inference and systems programming.

value: Show HN: 100% local speech dictation app with wakeword detection

author: computerex


value: Show HN: Use Clean Architecture architecture in a PHP project


value: Gowrishankarhq

value:
I built this after getting frustrated with jumping between CloudWatch, kubectl, and 4 other tools every time something broke in prod.
You point it at your AWS, GCP, Azure, or Kubernetes setup and it gives you a root cause analysis in plain English — severity, evidence, and fix commands. Also does Terraform plan review, Dockerfile analysis, CI/CD log parsing, and SOC2/ISO27001 compliance estimates.
Free to try, no credit card. Would love harsh feedback from people who actually manage infrastructure.

value: Show HN: Khaga – AI Infrastructure Diagnosis for AWS, GCP, Azure and Kubernetes

author: Gowrishankarhq


value: agrath

value:
I built ThreadCrunch to solve a problem I kept hitting: needing to share an email thread with someone outside the conversation. Screenshots are ugly, copy-paste loses context, and forwarding dumps a wall of nested quotes on the recipient.
Forward any thread to share@threadcrunch.io and you get back a clean, readable URL. There's also process@ which runs AI analysis (tone, intent, action items, draft reply) for $0.20/thread.
You can sign up at the site, or just forward a thread — if you're not subscribed yet, the reply email includes a signup link and your threads get processed automatically once you are.
Tech stack: Cloudflare Workers + D1 (SQLite) + Email Workers for inbound, Vue 3 frontend on Pages, postal-mime for MIME parsing with a custom thread splitter that handles Outlook/Gmail/webmail formatting differences (RFC 3676 format=flowed was fun). AI analysis uses Claude Sonnet.
Every thread URL also has .md and .json endpoints if you want to pipe it into your own tooling.
Demo thread: https://threadcrunch.io/t/5qyi25qv Site: https://threadcrunch.io
$5/month, threads auto-delete after 7 days. Happy to answer questions about the Cloudflare Workers email pipeline or the thread parsing.

value: Show HN: Threadcrunch.io – Forward an email thread, get a clean shareable URL

author: agrath


value: ynnickw

value:
Hi HN,
I built AppLaunchFlow to help indie developers and small teams create App Store marketing assets faster.
When launching an app, you usually need a lot of materials:
• App Store screenshots
• promo graphics
• social media visuals
• marketing copy
Most tools only help with designing screenshots, but they don’t help with the actual marketing workflow.
So I built a tool that starts with your app screenshots and uses AI to extract the important information from them — features, UI structure, and value propositions — and then helps generate all the assets needed for a launch.
Main features:
- AI screenshot analysis – extracts features and messaging from your UI
- App Store screenshot generator – optimized layouts for iPhone & iPad
- Promo graphics generator – social media and marketing visuals
- Figma-style editor – fully customizable layouts, not locked templates
- App launch asset generator – quickly produce everything needed for a release
The goal is to become a complete launch toolkit for app developers.
Instead of spending hours in design tools, you upload screenshots and iterate quickly until you have polished assets ready for:
- App Store listing
- Product Hunt launch
- social media marketing
- promo graphics
This tool is mainly built for indie developers, small teams, and app agencies who want to ship fast without hiring a designer.
I’d love feedback from the HN community.
Website:
https://applaunchflow.com
Curious about what assets you usually create when launching an app
Thanks!

value: Show HN: AppLaunchFlow: AI tool that turns app screenshots into marketing assets

author: ynnickw


value:
Hi HN,
I built an open-source Bluetooth Low Energy (BLE) GATT server that emulates a Continuous Glucose Monitor (CGM) device.
The goal was to create a virtual CGM device so developers and researchers can test mobile apps and experiment with BLE protocols without needing expensive medical hardware.
The server implements the Bluetooth Glucose Service and simulates real-time glucose readings.
Some use cases:
• Testing CGM mobile applications
• Learning how BLE GATT services are implemented
• Security research on medical device communication
• Educational use for students learning Bluetooth protocols
It runs on Linux/Kali and can be set up in a few steps.
Planned future work includes exploring BLE data interception, replay attack simulations, and potential security hardening approaches.
Would love feedback from people working with BLE, medical devices, or embedded systems.

value: Show HN: Open-source BLE GATT server that simulates a CGM device


value: Show HN: CompScan, a local system health doctor (Rust, no telemetry)


value: nexiope

value:
https://fondayai.pages.dev/
Built this to help people figure out their actual skin type before buying skincare products.
Take a selfie → short survey → Gemini 2.5 Pro analyzes your face and
  returns:
  - Baumann skin type (OSNW, DRPT, etc.)
  - 10 skin scores (moisture, pores, redness, wrinkles, pigmentation, dark
  circles, radiance, etc.)
  - Estimated skin age
  - Personalized ingredient & routine recommendations

  Stack: React + Vite frontend, Express backend, Google Gemini 2.5 Pro for
  vision analysis, deployed on Cloudflare Pages. Added EN/KO/JA i18n support
  this week.

  Mobile optimized. No account required. Completely free.

value: Show HN: Free AI skin analyzer – Baumann type and 10 skin scores from a selfie

author: nexiope


value: backstabslash

value:
I built this after ccusage started giving me inconsistent results and felt heavier than I needed.
goccc reads your Claude Code JSONL logs directly and calculates costs locally — no API calls, no setup beyond dropping a config line in settings.json.
The thing I hadn't seen elsewhere: it surfaces which MCPs are active in the statusline, so you can see at a glance what's connected.
goccc -d 7 -all        # costs for the last week
goccc -monthly         # monthly breakdown
goccc -project webapp  # per-branch breakdown
It also works as a live statusline inside Claude Code showing session cost, daily total, context usage, active MCPs and current model.
Built in Go. Install via Homebrew or build from source.

value: Show HN: Goccc – Claude Code cost tracker with MCP visibility

author: backstabslash


value: johndamaia

value:
… or at least I tried.
As a developer, I always wanted to explore/design a new email experience. Email is one of those tool we check daily but its underlying experience didn’t evolve much. I use Gmail, as probably most of you reading this.
Arc brought taste to browsing the web. Cursor created a new UX with agents ready to work for you in a handy right panel.
So, I tried to bring them all together.
Right now this is just a demo[0] with mock data (it's a bit laggy) and frontend only. I’d love for you to give it a try and let me know what you think.
//
After playing around with the demo, if you think it’s interesting enough apply here[1]. Created this early access page to show that design, taste and craft are the future of software.
[0] https://demo.define.app
[1] https://define.app/early

value: Show HN: I built a new email interface

author: johndamaia

title: Show HN: I built a new email interface


value: bialamusic

value:
This major update. There is offline documentation included in the installer image now + some fixes.
I built this because I am tired of OSs turning into server-controlled clients. We are losing the ability to understand, let alone rebuild, the tools we use every day.
The Project: OneManBSD is a customized OpenBSD 7.8 installation image for i386 platforms.
The "Sovereign" Features:
Source in the Image: The installer includes sys.tgz, src.tgz, xenocara.tgz, and ports.tgz. You can go offline and rebuild the entire kernel and base system from the local drive.
No Bloat: I’ve avoided Gtk3 and Qt. The desktop uses JWM, XFE, and Nedit.
Hardware-Level Control: I’ve bypassed heavy audio daemons, using awk for notification beeps and raw mixerctl for hardware unmuting.
Offline Docs: Full documentation is included in the image for true independence.
Watch the 90-second demo (Boot speed & JWM setup): https://www.youtube.com/watch?v=2wHaoQhXOYY
My goal isn't to start a "distro" but to encourage others to build their own "OneMan" systems. The more versions and diversifications we have, the more freedom we keep.
I’d love to hear your thoughts on maintaining a source-only workflow on older hardware.

value: Show HN: OneManBSD – A self-containing OpenBSD build with all source in the ISO

author: bialamusic


value: ofershapira

value: Show HN: Terminal dashboard for managing Cursor cloud agents

author: ofershapira


value: ViDesk

value:
  I built a macOS utility for people who use multiple desktops. DeskShifter lets you name each desktop, colour-code them, and switch between them by clicking a small widget that sits on your screen.

  macOS doesn't give apps a way to see your desktops, so most tools use private APIs that Apple doesn't allow. DeskShifter discovers your desktops safely as you navigate through them — no private APIs, fully App Store compliant.

  It just got approved on TestFlight and I'm looking for feedback from people who actually use multiple desktops day to day.

  TestFlight link: https://testflight.apple.com/join/6vE8qsfS

  I'd love to hear what works, what's confusing, and what's missing. Happy to answer any questions about the technical approach too.

value: Show HN: DeskShifter – Name, colour-code and switch macOS desktops

author: ViDesk


value: ameyakhot

value: I've been working on this since the beginning of my discovery of llm-council by @karpathy. I've also built domain-specific deep agents and also built the autonomous explore and plan agents that work well to find next features. This is a very small beta version and will be improved a lot. This is v0

value: Show HN: Built a Cursor for Product Managers

author: ameyakhot


value: StupidoMaximo

value:
Hey HN!
We built SyncIntel, an internal tool we use at Comsync [https://comsync.in/] to power our other products, and we're excited to share what we've been building.
We kept running into a problem while building Comsync. Our competitor research was scattered everywhere. We'd run deep research through Gemini, Claude, and other AI tools, read through lengthy documents, and then... lose track of everything. Important insights would disappear into browser tabs and forgotten Google Docs. We needed a dead-simple way to track competitors, their customers, and turn that intelligence into action. So we built SyncIntel, which was first used as an internal tool to power our other products, and now we're making it available to everyone.
Competitor research shouldn't end at a PDF nobody reads again. SyncIntel takes it further. It discovers competitor customers, builds ideal customer profiles, finds matching prospects, and generates personalized outreach. All in one place, always up to date.
Whether you're actively building a product and need to understand your competitive landscape, or you're still in the planning phase doing market research, SyncIntel keeps everything organized and actionable.
Honestly, this started as a glorified bookmark manager for research reports. But we quickly realized the real value wasn't in storing competitor intel. It was in making it actionable. So we layered in ICP building, prospect matching, and outreach generation. The app went from "let's organize our research" to "let's turn competitor intelligence into revenue." Each iteration brought us closer to closing the loop between knowing who your competitors serve and actually winning those customers over.
We use SyncIntel every day internally at Comsync. This is the first product we're launching publicly, and we'd love your feedback.
What features would make this more useful for your workflow? We're also planning to integrate email clients, Apollo, etc. so that you can use it even more actionably.

value: Show HN: Compile all your competitor research in one place

author: StupidoMaximo


value: sankarebarri

value: Show HN: PyMath Preview – preview LaTeX math in Python docstrings inside VS Code

author: sankarebarri


value: shadowline

value:
Hey HN, I built TypeCrt because every typing test I tried had noticeable input lag at 150+ WPM. Monkeytype uses React. Keybr uses React. 10FastFingers feels like 2012. So I built one from scratch with vanilla TypeScript, vanilla CSS, and direct DOM manipulation — no React, no Vue, no Angular.
The result: zero perceptible input latency, even at 200+ WPM.
Some things I'm proud of:
- CRT terminal aesthetic with 50+ themes and a visual theme creator
- Adaptive practice mode ("KeyForge") that uses Markov chains to generate words targeting your weakest keys
- Per-word burst speed breakdown, keystroke heatmaps, consistency tracking
- Command palette (Ctrl+Shift+P), mechanical keyboard sounds, pace caret ghost
- Cloud sync via Firebase, tiered analytics dashboard
Tech stack: TypeScript (strict) + Vanilla CSS + Vite. ~15K lines. No dependencies beyond Chart.js and Firebase.
I'd genuinely love feedback from this community — especially on performance, UX, and what features would make you switch from your current typing tool.

value: Show HN: TypeCrt – Zero-latency typing test in vanilla TS, no frameworks

author: shadowline


value: akinalpfdn

value: Show HN: GridSnap–Open-source encrypted grid-based note manager (Tauri and Rust)

author: akinalpfdn


value:
Hey everyone, just a bit of context into what I built.
The essential question was - What do food tech companies despite being major competitors, have in common?
Their food delivery riders are all used as guinea pigs for online clout by influencers
You know what I mean, those videos where money or food is handed out as gifts to show what a generous person the giver is, or how they’re breaking the norm by showing kindness etc “…….”
Keeping aside my personal disdain for filming a good act for attention, the fact that they have no consideration for the drivers privacy even when editing the video is wild. You can make all those edit cuts but can’t blur the drivers face?
I built igotfilmed.com exactly for that.
I initially built it with 5 language versions for the majority i see in dubai - Hindi, Afrikaans, Nepali, Malayalam and Tagalog- planning to add more options later
Drivers can now report/submit filming incidents where they noticed they’ve been filmed quietly, their videos have been uploaded on social media without their explicit knowledge or permission or even times when they were asked for permission.
The idea is to create a centralized location where all food tech companies delivery drivers can be made aware of which areas are the most common for these issues and which category is the most common. And for the ones who’s videos have been submitted without their permission- I have a plan for that
The company where they work at etc is kept entirely private as it’s not shown on the site ever. Interestingly enough tho, 2 companies popped up all the time when I was collecting sample data (which is what you see on the map now)
The map legend colors do not denote the company. They’re just colors chosen randomly.
It’s free for them to use.

value: Show HN: I Built Glassdoor but for Food Delivery Drivers in Dubai


value: kuchin

value:
Inspired by https://component-party.dev (frontend frameworks comparison), I built one for ORMs.
Picking the right ORM is not trivial, even with AI it's easy to get lost.
e.g. for Python I use Django ORM: expressive syntax, migrations, built-in admin. Skip rest of Django's stack and pair it with FastAPI. It's nice to see how it compares to the rest of stack, even to be able to choose between Python and Typescript for the next project.
Would love to get feedback, especially on what comparisons to add next.

value: Show HN: Compare ORMs Side-by-Side

author: kuchin

title: Show HN: Compare ORMs Side-by-Side


value:
Hi HN! I'm Tae, a solo developer from Seoul. I've been building Mirra for the past year.
The problem: creating consistent social media content is a massive time sink for small businesses and creators. Writing posts, designing carousels, editing videos – it takes hours every week.
Mirra lets you go from a raw idea to ready-to-publish content in minutes:
- Type an idea or paste a URL → AI generates carousel slides, short-form video scripts, and captions
- Supports Threads, Instagram, LinkedIn, YouTube Shorts, TikTok
- Built-in scheduler to publish directly
The core insight was that most content tools focus on one format. Mirra treats your idea as the source of truth and adapts it to each platform's format automatically.
I'm a solo founder, so I'd love honest feedback – especially on what's missing or broken. Happy to answer any questions!

value: Show HN: Mirra – AI turns ideas into social media carousels and videos


value: padamkafle

value:
Hi HN,
I’m Padam, a developer based in Dubai.
Over the last 2 years I’ve been experimenting with the idea that AI inference might not require GPUs.
Modern LLM inference is often memory-bound rather than compute-bound, so I built an experimental system that virtualizes GPU-style parallelism from CPU cores using SIMD vectorization and quantization.
The result is AlifZetta — a prototype AI-native OS that runs inference without GPU hardware.
Some details:
• ~67k lines of Rust
• kernel-level SIMD scheduling
• INT4 quantization
• sparse attention acceleration
• speculative decoding
• 6 AI models (text, code, medical, image,research,local)
Goal:
make AI infrastructure cheaper and accessible where GPUs are expensive.
beta link is here:
https://ask.axz.si
Curious what HN thinks about this approach.

value: Show HN: AlifZetta – AI Operating System That Runs LLMs Without GPUs

author: padamkafle


value: Sharanxxxx

value:
Hi HN,
We built Notation by Fownd to address the 'documentation tax' that physical therapists pay after hours.
Most AI scribes are generic transcribers. We’re focusing on clinical reasoning — capturing the therapist's intent in real-time to build structured, compliant SOAP notes during the session.
Key Focus Areas:
- Real-time SOAP Alignment: Structured notes that follow medical standards.
- Clinical Reasoning Capture: Moves beyond simple speech-to-text.
- Niche-Specific Logic: Designed by PTs to avoid generic medical templates.
- Privacy & Compliance: Built for outpatient and home health security.
I’m happy to answer any questions about the tech stack or the clinical logic we're using!

value: Show HN: Notation – Real-time AI clinical notes for physical therapists

author: Sharanxxxx


value: ImaneIdrissi

value:
I built a private desktop app that shows you what you actually did during a work session, whether it matched your intent, and the behavioral patterns behind how you worked.
I used to reflect on my work from memory, but memory is unreliable. I'd think I spent an hour on a task when half of it actually went to jumping between tabs, checking messages, and re-reading the same pages. I'd tell myself the reason was that I was tired, when in reality the task just wasn't clearly defined yet.
How it works: you set your intent before a work session. The app silently tracks your window activity (no screenshots). You can log how you're feeling at any point, on your own terms, no notifications, no interruptions. When you're done, AI generates a behavioral report ,not just what you did, but why you worked the way you did, with actionable suggestions to improve next time.
Privacy was non-negotiable. Your data never leaves your machine. Everything is stored locally in SQLite. No servers, no accounts, no cloud. The only external calls are to Google Gemini to check your intent for clarity and to generate your report. It receives your intent, window titles, app names, and feeling logs. No file contents, no screenshots.
Built with Electron, React, TypeScript, SQLite, and Google Gemini.Free on macOS.
I'd love your feedback.

value: Show HN: Unblurry – Your memory lies about how you work

author: ImaneIdrissi


value: Show HN: AI Governance Architecture – DB-Governed, LLM-Agnostic, EU AI Act


value: WanderZil

value:
Hi HN! I built an unofficial Slay the Spire 2 wiki and database ahead of launch:
https://slaythespire2.gg
What’s live now:
- Character pages (all playable characters + mechanics/playstyle notes)
- Card database
- Relic and potion pages
- News + guide hub (official updates + breakdowns)
- Browser-based custom card maker tool (PNG export)
I started this because I wanted one fast, clean place to check game data during launch week, instead of jumping across scattered posts/screenshots.
Built with Next.js + TypeScript. I focused on SEO and route-level metadata so pages are easy to discover and share.
The game launches in a few hours, so I’m actively updating data and patch notes in real time.
Would love feedback on:
1) missing information,
2) search/filter UX,
3) what tools you’d want next (deck builder, run planner, etc).
Thanks!

value: Show HN: Slay the Spire 2 Wiki (database and card maker tool)

author: WanderZil


value: isaacgbc

value:
Hi HN,
I built Mnemora because every AI agent memory solution I evaluated (Mem0, Zep, Letta) routes data through an LLM on every read and write. At scale, that means 200-500ms latency per operation, token costs on your memory layer, and a runtime dependency you don't control.
Mnemora takes the opposite approach: direct database CRUD. State reads hit DynamoDB at sub-10ms. Semantic search uses pgvector with Bedrock Titan embeddings — the LLM only runs at write time to generate the embedding vector. All reads are pure database queries.
Four memory types, one API:
1. Working memory: key-value state in DynamoDB (sub-10ms reads)
2. Semantic memory: vector-searchable facts in Aurora pgvector
3. Episodic memory: time-stamped event logs in S3 + DynamoDB
4. Procedural memory: rules and tool definitions (coming v0.2)
Architecture: fully serverless on AWS — Aurora Serverless v2, DynamoDB on-demand, Lambda, S3. Idles at ~$1/month, scales per-request. Multi-tenant by default: each API key maps to an isolated namespace at the database layer.
What I'd love feedback on:
1. Is the "no LLM in CRUD path" differentiator clear and compelling?
2. Would you use this over Mem0/Zep for production agents? What's missing?
3. What memory patterns are you solving that don't fit these 4 types?
Happy to answer architecture questions.
SDK:
pythonpip install mnemora
from mnemora import MnemoraSync
client = MnemoraSync(api_key="mnm_...")
client.store_memory("my-agent", "User prefers bullet points over prose")
results = client.search_memory("output format preferences", agent_id="my-agent")
# [0.54] User prefers bullet points over prose
Drop-in LangGraph CheckpointSaver, plus LangChain and CrewAI integrations.
Links:
5-min quickstart: https://mnemora.dev/docs/quickstart
GitHub: https://github.com/mnemora-db/mnemora
PyPI: https://pypi.org/project/mnemora/
Architecture deep-dive: https://mnemora.dev/blog/serverless-memory-architecture-for-...

value: Show HN: Mnemora – Serverless memory DB for AI agents (no LLM in your CRUD path)

author: isaacgbc


value: Show HN: A framework for building nexuses of agents


value: moorst

value:
Chartle generates charts from natural language. You type something like "programming language popularity over the last 10 years" and it finds the data, picks the chart type, and renders it. You can also screenshot an existing chart and it recreates it as something clean and editable.
Built with Next.js/TypeScript, Gemini with Google Search grounding for data retrieval, and ECharts for rendering.
Free to try, no signup needed for your first chart. Free tier gives you 5 charts/month.

value: Show HN: Chartle – Describe a chart in plain English and it creates it

author: moorst


value: maxhofer

value:
Hi HN! We're X25 alumni and built Parsewise to analyze large document sets with AI agents.
Instead of prompting a single PDF, our agents extract, cross-reference, and reason across thousands of documents in one run.
We originally built this for insurance and financial diligence workflows where teams review huge document packs.
Curious what the HN community thinks!
Check out our public demos:
demo.parsewise.ai/insurance-claims-triage
demo.parsewise.ai/reinsurance-recovery-optimization
demo.parsewise.ai/investment-diligence
demo.parsewise.ai/mortgage-underwriting

value: Show HN: Parsewise – Cursor for Business Documents

author: maxhofer


value: sandippathe

value:
I built Anaya to solve a problem I kept seeing:
India's DPDP Act is now enforceable (rules notified Nov 2025, deadline May 2027) but compliance is a code problem, not just a legal checklist. No tooling existed for it.
Ran it on Saleor (open-source Django e-commerce, 107 models): found 4 violations in 82 seconds — no consent mechanism, 70 PII fields stored plaintext, zero DELETE endpoints for any PII model.
pip install anaya && anaya compliance .
Code: https://github.com/sandip-pathe/anaya-scan
Happy to discuss the AST parsing approach or the DPDP section analyser design.

value: Show HN: Anaya – CLI that scans codebases for DPDP compliance violations

author: sandippathe


value: openmaiwaifu

value:
She sits on your screen, watches what you do, and develops her own personality over time .
4-tier memory → emotions → personality islands → beliefs
Open source.
Any VRM model.

value: Show HN: I built an AI desktop Waifu that remembers you

author: openmaiwaifu


value:
I wrote a tutorial explaining how to build a simple real-time chat server
using WebSockets and Redis Pub/Sub in .NET.
The article walks through the architecture and implementation of a server
that supports channel subscriptions, message publishing, and fanout
using Redis.
Topics covered:
- WebSocket connection handling
- Redis Pub/Sub for message distribution
- inbound/outbound message loops
- channel subscription management
- basic architecture for real-time messaging systems
The full source code is available here:
https://github.com/sanzor/Ctesiphon
Would be curious to hear feedback from people working on messaging
infrastructure or real-time systems.

value: Show HN: Building a WebSocket Chat App with C#, Redis Pub/Sub and .NET


value: maxharrison

value:
To-do apps are the canonical overengineered demo. This one leans into that - and offloads the overengineering to you.
This is mostly an experiment, but I've put a bit of effort making it into a little platform people can play around with.
With the advances of LLMs being able to one shot some frontend code, I thought it would be a fun experiment to have a end-user facing vibe coding app, following the ideas of malleable software.
It allows users to change the full theme and design from a single prompt, but also and more importantly, allowing the end-users to add features such as categorisation or kanban.
Please let me know any feedback, try to break it etc.
(posted on crappy internet 3800m above sea level)

value: Show HN: I made a to-do list app where users use LLMs to rewrite their front end

author: maxharrison


value: Show HN: Tool to test brand presence across major LLMs


value: Show HN: PromptPerfect – Open-source prompt optimizer for LLMs


value: pranshuchittora

value:
Hey HN
I've been building mobile apps for half a decade. There are so many moments where you need to quickly check something — how does this screen look on a 12-inch device? Does the layout break in German where translation strings are twice as long? Does the geo feature work when the user is in Tokyo?
Then there's the everyday stuff — clearing app data to re-test onboarding, installing a fresh build on three devices at once, toggling dark mode to check contrast, sending a test push notification with a specific payload, grabbing screenshots for the App Store listing, checking what's actually in the local SQLite database when state looks wrong.
Each of these is a few terminal commands, a trip to Xcode/Android Studio, or some menu buried three levels deep. Over the years I wrote a lot of bash scripts. Then bash aliases. Then more scripts to chain the aliases together.
To consolidate all of that and make the DX actually pleasant, I built Simvyn — a local web dashboard + CLI that wraps simctl, adb, and devicectl into one interface. npx simvyn starts it up, discovers all your iOS Simulators, Android Emulators, and USB/WiFi-connected devices, and gives you everything from one place. No SDK, no app-side changes — works with any framework.
Try now > npm simvyn
If you've ever rage-typed adb commands at 2 AM, a star would mean a lot :)
GitHub - https://github.com/pranshuchittora/simvyn

value: Show HN: Simvyn – Universal mobile devtool, no SDK required

author: pranshuchittora


value: steveharrison

value: Show HN: MacBook Neo page scroll > video position effect

author: steveharrison


value: nullAffi

value: Show HN: DevTrack – A personal dashboard to track your developer growth

author: nullAffi


value: liweixin

value: Show HN: podcast-cli - A Rust CLI for Podcast Index & YouTube Subtitles

author: liweixin


value: agentzz

value: Show HN: Discord Voice AI – Self-hosted bot that talks in voice channels

author: agentzz


value:
Hey HN — I built this because every time I started a new project with Claude Code, I'd spend an hour writing a CLAUDE.md that was either too generic to be useful or too project-specific to reuse.
The insight is that good CLAUDE.md files need to be stack-specific. What Claude gets wrong in a Next.js App Router project is completely different from what it gets wrong in a FastAPI backend. Generic advice doesn't cut it.
Each template includes concrete rules (not platitudes), a "NEVER DO THIS" section with real anti-patterns, specific library preferences with reasons, and file naming conventions with examples.
Happy to take requests for stacks that aren't covered.

value: Show HN: Awesome-Claude-md – 20 stack-specific Claude.md templates for AI coding


value: imMovie

value:
React Native + Expo. No backend. 1–2 hours/day on weekday evenings.
App: https://apps.apple.com/app/id6758666723
## Why this app
I built this app because I needed it myself.
For a while my days kept ending and I couldn't name what actually went right. I tried affirmations skeptically. Surprisingly, they helped — not by making hard things easy, but by making them easier to start. That small shift mattered.
So I built something I was already using.
Background: 13 years as a frontend architect working with monorepos, distributed state, and CI/CD. For this project I intentionally chose something simple. The goal wasn’t technical complexity — it was product thinking and shipping something end-to-end.
Affirmation apps look simple. The real challenge is the loop: showing meaningful content at the right moment, making it feel personal, and helping it become a habit.
Being the primary user gave me strong opinions about the experience. That’s a real advantage when building solo.
## Stack
React Native with Expo. No backend.
Local storage for preferences, push notifications for reminders, and client-side content curation.
Why not SwiftUI? I'm simply faster in React. Expo handled notifications, App Store submission, and OTA updates without requiring deep iOS infrastructure work.
## What AI actually did — and didn’t
The generic “AI helped me code” narrative isn’t very useful.
### Where AI helped
- Navigation structure and state patterns — about *70–80% usable on first pass*
- Notification scheduling skeleton
- Structuring ~200 affirmations into categories and tags
- Drafting initial App Store copy
- Surfacing edge cases when describing features
That saved a meaningful amount of time.
### Where AI failed
*Onboarding design.*
AI suggestions were functional but generic. Good onboarding for an affirmation app requires understanding the emotional context — why someone opens it at 7am and what friction kills the habit before it forms.
I scrapped the generated flow and rebuilt it manually.
*Notification timing.*
AI suggested a single daily reminder. Instead I designed three slots:
- morning intention
- midday reset
- evening reflection
That decision came from thinking about real usage.
AI can implement decisions. It usually can’t make them.
I also discovered a subtle bug in the AI-generated notification scheduling code that occasionally caused duplicate reminders when the app was backgrounded. Fixing it required real debugging and reading Apple’s background task lifecycle documentation.
AI suggestions are useful — but they should always be treated as *hypotheses*, not production-ready answers.
## Admin panel
I built a small content admin panel early to manage affirmations without redeploying.
Using the app daily quickly created new ideas:
> “This affirmation needs voice narration.”
> “This one works better with a background video.”
Because the content schema was flexible, adding media didn’t require architectural changes.
Lesson: *if you're the primary user, build content control early.*
I waited until week 7.
## Timeline
- *Weeks 1–2:* architecture and data model
- *Weeks 3–4:* core screens
- *Week 5:* onboarding
- *Week 6:* notifications and timezone handling
- *Week 7:* admin panel and media support
- *Week 8:* TestFlight and App Store release
Total time: ~8 weeks working evenings.
AI likely saved around *20–30% of implementation time*. The harder parts — product decisions, UX judgment, and debugging — didn’t compress nearly as much.
## Worth it?
Downloads are still modest.
But my alarm is now the affirmation from the app I built. That’s the real outcome.
Shipping solo reinforced something important: the hardest part of development isn’t writing code.
It’s understanding the real problem you’re solving — and making thoughtful decisions about how to solve it.

value: Show HN: I built a daily affirmation iOS app solo — what AI actually helped with

author: imMovie


value: burakoktenli

value:
Hi HN,
I built a small architecture exploring how autonomous systems can manage operational authority when sensor trust degrades or environmental threats increase.
The model computes a continuous authority value A ∈ [0,1] based on four inputs:
• operator quality
• mission context confidence
• environmental threat
• sensor trust
The authority value maps to operational tiers that determine what actions an autonomous system is allowed to perform.
I included:
– deterministic simulation engine
– reproducible Monte Carlo experiments
– interactive demo
– technical report with DOI
Demo:
https://burakoktenli-ai.github.io/hmaa
Technical report:
https://doi.org/10.5281/zenodo.18861653
I'd love feedback from engineers working on robotics, safety-critical systems, or AI autonomy.

value: Show HN: Hierarchical Mission Authority Architecture for autonomous systems

author: burakoktenli


value: oser

value: Show HN: A logic puzzle game I built for my 5-year-old daughter(mostly AI coded)

author: oser


value: hamzzaamalik

value:
Hi HN,
I built *CodeDrift*, a CLI tool that detects bugs commonly introduced by AI coding assistants like Copilot, Cursor and ChatGPT.
Over the last year I noticed that AI tools often generate code that compiles correctly, passes linting and looks reasonable in code review but still contains subtle issues.
Some common examples I kept seeing:
* async `forEach` loops that never await promises
* missing authorization checks (IDOR)
* hallucinated dependencies that don’t exist
* stack traces leaking sensitive information
* request data used without validation
These bugs often slip past ESLint, TypeScript and even human reviewers because the code looks correct.
CodeDrift parses the code using the TypeScript compiler API and runs a set of detectors looking for these patterns.
Example:
```
async function syncProducts(items) {
  items.forEach(async (item) => {
    await updateStock(item.id);
  });
}
```
CodeDrift output:
```
CRITICAL: async forEach does not await promises
Fix: use Promise.all or a for...of loop
```
Another example it detects:
```
Database query using user-supplied ID without authorization check
→ potential IDOR vulnerability
```
The goal isn’t to replace tools like ESLint or TypeScript, or security scanners like Snyk.
It’s meant to act as a safety layer for code generated with AI assistants.
The tool runs locally, requires no cloud access, and can be tried with:
```
npx codedrift
```
I’d love feedback from developers who are using AI coding tools in production.

value: Show HN: CodeDrift – static analysis for AI-generated code

author: hamzzaamalik


value: foamzou

value:
Built Scrollie, an iOS app for long screenshot workflows.
Main use case: convert recordings (or screenshot sequences) into one long image with less manual work.
Current focus:
- on-device stitching
- export editing (blur/mosaic, text, shapes, watermark)
- draft auto-save + resume
App Store:
https://apps.apple.com/app/scrollie/id6757146579
Launch promo is live now (~48h): Lifetime unlock is free.
Ends: Mar 7, 2026 08:01 UTC
Claim path: Settings -> Upgrade to Pro -> Lifetime (Free / $0)
If claimed at $0 now, Lifetime stays unlocked permanently with no auto-charge later. Early-bird pricing applies only to users who miss this free window.

value: Show HN: Scrollie – turn iPhone recordings into long screenshots

author: foamzou


value: modinfo

value: Show HN: A minimalistic, elegant, and local-first family meal planner

author: modinfo


value: redpangilinan

value: Show HN: Crikket – An open source, self-hostable alternative to jam.dev

author: redpangilinan


value: neojakey

value:
I built PulseTech.news because I was tired of "heavy" tech news sites. I wanted a lightning-fast, zero-bloat aggregator that I could check in 30 seconds to get the global pulse.
Technical Highlights:
* Performance: Built on a lean PHP/MySQL stack for sub-100ms page loads. No heavy frameworks, just vanilla performance.
 * Automation: A headless background scraper (bin/scrape.php) runs on an hourly cron cycle to digest, categorize, and deduplicate headlines from the world’s top tech sources.
 * Privacy-First: Implemented Google Consent Mode v2 and PII-free click tracking to be fully GDPR/CCPA compliant without compromising analytics.
Semantic Web: Every listing is backed by dynamic JSON-LD ItemList schemas, making the site highly discoverable by search engines.
 * I’ve spent the last few days fine-tuning the automated categorization engine to ensure that "AI" news stays in AI, "Cybersecurity" stays in security, etc., based on a weighted keyword detection system.
I'd love to hear your feedback on the speed, the UI (especially the dark mode), and any other tech sources you think I should add to the automated engine!

value: Show HN: PulseTech.news – an automated, privacy-first tech aggregator

author: neojakey


value: njoerd

value:
I built an MCP server that connects AI assistants to live KubeCon + CloudNativeCon Europe 2026 data (March 23-26, Amsterdam).
It exposes 12 tools that let you search 500+ sessions, find speakers, discover evening parties, get venue/hotel/transit info, score sessions based on your role and interests, and detect scheduling conflicts. Data is pulled live from the official sched.com iCal feed and conferenceparties.com.
Install: uvx kubecon-eu-mcp
The fun part: KubeCon has a co-located "Agentics Day: MCP + Agents" event on Monday, so this is an MCP server to help plan your trip to the MCP event.
Built with Python, FastMCP (official MCP SDK), httpx, icalendar, and BeautifulSoup. No database, no config — just install and ask questions. MIT licensed.
GitHub: https://github.com/njoerd114/kubecon-eu-mcp
PyPI: https://pypi.org/project/kubecon-eu-mcp/

value: Show HN: MCP server for KubeCon EU 2026 – AI-powered conference planning

author: njoerd


value: nirox

value: Show HN: NiroDB – A key-value storage engine built from scratch in Go

author: nirox


value: konstantinkai

value: Show HN: PeekAPI – API analytics middleware, 7 languages, zero dependencies

author: konstantinkai


value: alanalvestech

value: Show HN: HiTank – A skill manager for Claude Code, written in pure Ruby

author: alanalvestech


value: [Higher resolution, but possibly much more computationally demanding, version](https://marl0ny.github.io/split-operator-simulations/js/3d.h...). [2D version](https://marl0ny.github.io/split-operator-simulations/js/2d.h...). This was actually posted here long ago by someone else, where the comments were basically about not being able to run it in the first place. Well recently I've increased device compatibility, but even on some devices it may not run properly. For all Android devices I have to use a JavaScript FFT fallback instead of the default GLSL implementation, so expect significantly slower performance here. But even on some lower-end Android devices, it may not even run at all, so expect a black screen. I've also heard an issue where some of the GUI controls or buttons do not work; as I haven't been able to reproduce this, I suspect this is due to conflicts with browser extensions.

value: Show HN: 3D linear and nonlinear WebGL Schrödinger numerical solver