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

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


value: wayy

value:
Hey all, Justin here. I previously built Phind, the AI search engine for developers.
One of the biggest problems we had there was figuring out what went wrong with bad searches. We had tons of searches per day, but less than 1% of users gave any explicit feedback. So we were either manually digging through searches or making general system improvements and hoping they helped.
This problem gets harder with agents. Traces are longer and more complex. It takes more effort to review them, so I'm building a tool that lets you analyze LLM outputs directly to help developers of LLM apps and agents understand where things are breaking and why.
I've put together a demo using browser-use agent traces (gpt-5): https://trails-red.vercel.app/viewer
It's early, but I have lots of ideas - live querying of past failures for currently-running agents, preference models to expand sparse signal data.
Would love feedback on the demo. Also if you're building agents and have 10k+ traces per day that you're not looking at but would like to, I'd love to talk.

value: Show HN: 83 browser-use trajectories, visualized

author: wayy


value: Bayram

value:
I kept copy-pasting the same question between Claude, Codex, and Gemini CLIs - one reviews the other's work, back and forth until I'm satisfied. Decided to automate myself out of the loop.
This is Scott Page's "many model thinking" in action: each model has its own character and blind spots,so triangulating between them often catches things a single model misses.
Three modes:
- Deliberate: one agent generates, another reviews, they iterate until consensus
- Council: parallel opinions + anonymous peer ranking + synthesis (inspired by Karpathy's llm-council)
- Debate: two agents argue pro/con, a third judges
Requires 2+ of: Claude Code, Codex, or Gemini CLI.

value: Show HN: Multi-agent deliberation plugin for Claude Code

author: Bayram


value: tothemoon

value:
Hi HN,
I made a chess-themed puzzle game called Hexpiece! You place 6 chess pieces on the board to "light up" as many squares as possible. Some squares are blocked, and there's a new puzzle every day.
There are two modes: Classic, where you try to get the highest possible score, and Perfect, where there is a guaranteed perfect solution.
Any feedback would be greatly appreciated! I tried to make a game that even someone with a cursory knowledge of chess could enjoy.

value: Show HN: Hexpiece – a daily chess coverage puzzle

author: tothemoon


value: justvugg

value:
Hi HN,
I built PolyMCP, a framework to make building MCP (Model Context Protocol) servers and integrating agents much easier.
Working with MCP and agent tooling often comes with repetitive or frustrating challenges:
•Exposing Python functions as discoverable tools can be tedious.
•Orchestrating multiple MCP servers usually requires a lot of glue code.
•Debugging multi-server setups is tricky without good visibility into calls, inputs, and outputs.
•Integrating agents with LLMs to automatically discover and call tools is still immature in most setups.
PolyMCP addresses these pain points:
•Flexible tool exposure – Expose Python functions as MCP tools with minimal boilerplate. Supports HTTP, in-process, or stdio execution.
•Real-time Inspector – Monitor tool calls live, inspect inputs/outputs, and test interactions interactively.
•Built-in agent support – Agents can automatically discover and invoke tools with multiple LLM providers.
•CLI and workflow tooling – Quickly scaffold, test, and run MCP projects without tedious setup.
The goal is to make MCP server development and multi-tool agent orchestration faster and less painful.
Check it out here: https://github.com/poly-mcp/Polymcp
I’d love to hear feedback, ideas, or suggestions!

value: Show HN: PolyMCP – Simplifying MCP Server Development and Agent Integration

author: justvugg


value: vlebo

value:
Hey HN,
I built ctx because I was tired of the mental overhead of managing multiple client environments. Every context switch meant: change AWS profile, switch kubeconfig, start the right SSH tunnels, set the right env vars, remember which VPN i need to connect to.
Miss one step and you're deploying to the wrong environment.
The problem: Existing tools are siloed. kubectx handles Kubernetes. aws-vault handles AWS. direnv needs .envrc files everywhere. SSH tunnel managers don't know about your cloud context. Nothing ties them together.
ctx does one thing: Atomic context switches across all of these at once.
ctx use client-a-prod
# Now your shell has:
# - AWS_PROFILE=client-a-prod
# - KUBECONFIG pointing to their cluster
# - Nomad/Consul env vars set
# - SSH tunnels to their bastion started
# - VPN connected
# - Secrets loaded in env
Key features:
- Single YAML per context defines everything
- CLoud SSO integration - detects expired sessions, triggers login automatically, caches tokens so switching back is instant
- Browser profiles - ctx open grafana opens Chrome/Firefox with the right profile (useful when each client has different SSO/Google accounts)
- SSH tunnels auto-start on context switch, auto-reconnect on failure
- Production safety: color-coded prompts, confirmation required for prod contexts
- Per-terminal isolation - different terminals can be in different contexts simultaneously
- Shell integration for bash/zsh/fish
Written in Go, single binary, no dependencies.
GitHub: [https://github.com/vlebo/ctx/]
I'd love feedback on the design. The config format took a few iterations to get right - balancing simplicity with flexibility for complex setups.

value: Show HN: Ctx – Context manager for Cloud,K8s VPNs, SSH tunnels, secret managers

author: vlebo


value: TheBestTvarynka

value:
Hello HN,
For the last 3 years, I have been working on a tool that helps me debug ASN.1-encoded data (keys, certificates, Kerberos/CredSSP/SPNEGO/etc tokens, and more), cryptographic operations, and JWTs.
This app is available online; you can try it [0] (no sign-in/up needed).
First, this app supported only various cryptography operations.
Then, I started working with JWTs a lot, and I did not like jwt.io design at all. So, I made my own JWT debugger without ads, banners, and other crap.
And last but not least, I also implemented the ASN1 debugger over the years. The best feature is that you can edit the ASN1 tree directly on the page [1].
I'm happy that I wrote this tool. I use it often to help me debug my protocol implementations. I know that some of my friends use the JWT debugger and ASN1 parser from this tool. Maybe some of you will find it helpful too.
The app is open-source [2]. All computations are performed on the client side. Related submissions: [3], [4].
[0]: https://crypto.qkation.com/
[1]: https://news.ycombinator.com/item?id=46255464
[2]: https://github.com/TheBestTvarynka/crypto-helper
[3]: https://news.ycombinator.com/item?id=46255464
[4]: https://news.ycombinator.com/item?id=46267963

value: Show HN: Cryptography, JWT, and ASN1 Debuggers

author: TheBestTvarynka


value: ruben-davia

value:
Hi HN,
We’re Ruben, Afnan, and Theo, and about a month ago we started working on a beta webapp for a more visual roleplay experience.
We felt that roleplay works best when it feels like a real conversation, not like reading a chat log. So we focused on a phone-exchange format, where characters message you as if they’re on the other end of your phone and can send images that evolve with the story and react to what’s happening.
Since the first beta, we’ve been building around a few core ideas:
- Native memory for every character, so they keep context and remember past interactions
- No ads, no interruptions, just the experience
- Unlimited character creation, to build as many worlds and characters as you want
iOS: https://apps.apple.com/us/app/davia-visual-ai-chat-platform/...
Android: https://play.google.com/store/apps/details?id=com.davia.app
It’s still early, and we’re actively iterating.
We’d love to hear what you think and what you’d improve in this kind of experience. :)

value: Show HN: Davia – Visual AI roleplay with image-based conversations

author: ruben-davia


value: kraklabs

value: Show HN: CIE – Open-source code intelligence engine for AI coding assistants

author: kraklabs


value: LetsBuildThis

value:
Most fonts sites are trash, G Fonts is the only way for proper free fonts. BUT...
...even G Fonts is more okay than good: Many good fonts are lost in the deep of hundreds of bad fonts and export is tricky, too.
I've build a solution: A free font library with only top fonts, better UI/UX, custom coloring, easy exports and IDE support (for vibe coding and such)
Find perfect fonts in seconds, and export within a few clicks.
Try it for free: BestFonts.co
And please give me your honest feedback!!
Thx
Justin

value: Show HN: Free Top Font Library: Bestfonts.co – Find Free Top Fonts in Seconds

author: LetsBuildThis


value:
Hey HN, I'm Jagger.
Like a lot of developers, I was frustrated by the discovery problem in the Roblox ecosystem. Finding an active, quality event is a fragmented nightmare that involves checking:

    Discord Announcements

    YouTube streams/guides

    Reddit threads

    Endless in-game scrolling

It's an anti-pattern that wastes player time.
We built a centralized tool to solve this: a unified event aggregator that allows users to find the perfect event instantly.
Key Features:

    Advanced Filtering: Sort by Age, Vibe, and Prizes to cut through noise.

    Live Data Integration: See real-time player counts and time remaining on rewards before you commit to joining a server.

    Vision: To be the single, reliable API for event-related metadata in the Roblox metaverse.

We want players spending their time in-game, not searching external platforms.
I'd appreciate any feedback on the technical implementation, data accuracy, and user experience.
Also any votes on PH would be appreciated:
https://www.producthunt.com/products/bloxrn?launch=bloxrn

value: Show HN: The one-stop-place for gen-alpha events


value: ezulabs

value:
Vibe-coded a CLI tool that lets you select commands from your console history using a TUI, auto-recognizes parameters, and generates AI skills for Claude/Cursor.
https://www.npmjs.com/package/@ezulabs/skillgen-cli
https://github.com/ezulabs/skillgenerator/

value: Show HN: Skill Generator – Turn terminal workflows into AI agent skills

author: ezulabs


value: fullofdev

value: What should I add? What AI tools have been helpful for you as developers?

value: Show HN: Collecting AI Developer Tools

author: fullofdev

title: Show HN: Collecting AI Developer Tools


value: nirvanist

value: Show HN: My mouse was sending two clicks instead of one – I built a tester

author: nirvanist


value: olliepro

value:
This skill is useful for identifying agent friction points and brainstorming new skills, developing context of past work for a new conversation, identifying code bloat from failed solutions, etc.
It is a simple Codex meta-"skill" that uses a CLI to analyze your past Codex sessions and generate reflections. It uses headless Codex subagents running in parallel on temporary copies of conversation history. These reflections are orchestrated by the CLI and a Codex agent can synthesize them for downstream use. Reflections are cached for efficiency.
Repo: https://github.com/olliepro/Codex-Reflect-Skill

value: Show HN: Codex Self-Reflect Skill and CLI to run subagents on past Codex convos

author: olliepro


value: am-seo

value:
Hey all, first time posting. I posted about this on linkedin and a friend said I should post here too
I run a lot of headless Screaming Frog crawls on servers.
The main bottleneck is that while the SF CLI can consume configuration files (.seospiderconfig), it cannot produce them. If you want to run a crawl with complex settings (like custom extractions or specific excludes), you are forced to open the desktop GUI, configure it manually, save the file, and upload it.
You can't just script the file generation because the configs are serialized Java objects (binary blobs), not JSON or XML.
I decided to reverse engineer it. A hex dump confirmed the format was standard Java serialization. Instead of writing a fragile parser, I realized I could use the application's own JARs to handle the heavy lifting.
I built two tools to solve this:
Python Library: Uses JPype to bridge Python to the local SF JARs. You can instantiate config objects, modify them (e.g., config.set_user_agent(...)), and serialize them back to disk. Great for Airflow/Python pipelines.
Java Utility: A standalone CLI tool to do the same thing if you prefer a native Java environment or don't want the Python overhead.
What this enables:
True Headless Automation: Generate valid configs on the fly right before a crawl runs.
Diffing: Compare two binary config files to debug "config drift" (e.g., seeing exactly why a crawl limit changed).
Feedback welcome—especially on the JPype implementation, as that was the trickiest part to stabilize!

value: Show HN: Python lib and Java CLI tool to read/write Screaming Frog config files

author: am-seo


value: scordata

value: Show HN: Statutory – a Turing-complete language in 17th-century legal English

author: scordata


value:
NeuralVoid is a free Windows tool that stops AI apps from sending your data home.One click adds blocks to your hosts file (with backup) for:
Grammarly
Adobe (Photoshop/Firefly)
Microsoft Copilot/Edge
More common endpoints
No extra software running. Fully reversible.Built because AI "helpers" shouldn't spy on everything you type.
Open source, MIT license.
Run the EXE or check the Python source.

value: Show HN: NeuralVoid – Block AI Telemetry from Copilot, Grammarly, Adobe


value: saisrirampur

value:
Hello HN, this is Sai and Kaushik from ClickHouse. We are launching a Postgres managed service that is natively integrated with ClickHouse. We built this in partnership with Ubicloud (https://www.ubicloud.com/)
What do you get: It offers NVMe-backed Postgres + built-in CDC into ClickHouse + pg_clickhouse so you can keep your app Postgres-first while running analytics in ClickHouse.
Try it (Sign up for private preview): https://clickhouse.com/cloud/postgres
Live demo: https://www.youtube.com/watch?v=rpBA13nQxAk&t=4s
Detailed technical blog: https://clickhouse.com/blog/postgres-managed-by-clickhouse
Problem - Scaling limits of Postgres for OLTP and OLAP
As companies grow on Postgres, they often start to run into performance limits, both for transactions and analytics. On the OLTP side, things like slow updates and upserts, painful vacuums, and WAL spikes from long-running transactions are common, usually driven by disk I/O bottlenecks. With fewer I/O constraints, Postgres could handle a lot more.
On the analytics side, many limitations come from the fact that Postgres was designed for OLTP and lacks features common in analytical databases, such as vectorized execution and broad ingest format support. As a result, many companies (e.g., GitLab, Ramp, Cloudflare) complement Postgres with ClickHouse to offload analytics, adopting two purpose-built open-source databases.
However, adding ClickHouse to a Postgres-based application isn’t straightforward—you typically need to build CDC pipelines, manage backfills and schema changes, and update application code to handle a second database.
Solution - NVMe-backed Postgres natively integrated with ClickHouse
On the OLTP side, NVMe-based Postgres can dramatically improve performance. By colocating storage with compute, NVMe enables much lower latency and higher IOPS than network-attached storage, speeding up disk-bound operations (up to 10x), including updates, upserts, vacuums, and checkpointing. We’re working on a detailed blog exploring how NVMe reduces WAL fsync, buffer read, and checkpoint overhead, stay tuned!
On the OLAP side, the Postgres service offers native CDC to ClickHouse and unified querying via pg_clickhouse. CDC is currently powered by ClickPipes/PeerDB using logical replication, and we’re working to make it faster and simpler with logical replication v2, a new decoding plugin, and a path toward sub-second replication.
Every Postgres comes with the pg_clickhouse (https://github.com/ClickHouse/pg_clickhouse) extension, which simplifies adding ClickHouse-powered analytics to a Postgres application. It lets you query ClickHouse directly from Postgres, enabling a single interface for transactions and analytics. pg_clickhouse supports broad analytics query pushdown, with plans to expand this further over time.
Who is it for?
1. Companies who are looking for a faster and more scalable Postgres.
2. Companies already using ClickHouse that want a tightly integrated Postgres to offload analytics to ClickHouse, without the operational burden of managing the integration.
3. Companies that are growing rapidly (or expect to) and want a simple yet powerful stack with Postgres on NVMe + ClickHouse.
CTA
1. If the above value and vision resonates with you and you want to try it for a use-case, please sign up here and we will give you access within a day or two! https://clickhouse.com/cloud/postgres
2. We’d love to hear your feedback and anything else that comes to mind, it would be super helpful to us as we build this out!

value: Show HN: ClickHouse Managed Postgres

author: saisrirampur

title: Show HN: ClickHouse Managed Postgres


value: cabyambo

value:
I built a dynamic QR code tool that helps optimize the conversion rates of your CTA when using QR Codes.
I recently closed my first enterprise deal and am working to get more.
Some of our specific features are:
- A/B testing QR code destinations
- Updating a QR codes destination after the fact
- Having a QR code cycle through thousands of links

value: Show HN: Nodal – QR Code Conversion Optimization

author: cabyambo


value: phntmdz

value: Show HN: We added a CLI for receiving webhooks locally (no ngrok required)

author: phntmdz


value: LSENNN

value:
Hi HN,
I'm the author of NULL FUTURE.
While most discussions focus on the 'replacement' aspect of AI (layoffs), I wanted to explore the 'deprecation' phase that comes first. My thesis is that we are entering an era of 'Invisible Replacement' where white-collar workers keep their titles but lose their utility, effectively becoming 'Null Workers'—paid to exist but functionally obsolete.
The book explores strategies to pivot from 'Efficiency' (which AI wins) to 'Liability/Accountability' (which remains human).
It's free on Amazon for the next few days. I wrote it as a survival manual rather than a business book.
I'd love to hear your thoughts on the 'Liability Sponge' concept if you give it a read.
(Direct Amazon link is in the post)"

value: Show HN: Null Future – A survival guide for the AI economy (Free)

author: LSENNN


value: aleksam

value:
I got very good at SEO (particularly the tech side) and free tools.
I started recently doing some collabs as well.
What is currently slowing me the most is creating on-brand images related to the content, by far.
I was using AI to generate images, but it needed constant hand-holding, prompting, and control.
So I built BlogImageGen, which helps me build on-brand, context-related images in predefined styles and formats.
Would love to hear your feedback.

value: Show HN: On-brand, context-related <img> generation for blogs

author: aleksam


value:
I have 5000+ screenshots and can never find anything. Built a tool to fix that.
ssm find "that stripe error" → finds the screenshot with the Stripe error message
It uses OCR to extract text and a local vision model (Ollama) to describe photos. Everything runs locally, no API keys.
The search is semantic so "connection failed" finds "network error" too.
What surprised me: indexing is the slow part (~2s per image for OCR). Search is basically instant.
Code: https://github.com/memvid/screenshot-memory
Would love feedback on the CLI UX.

value: Show HN: I built a CLI to search screenshots by what's in them


value: Show HN: RIR– prevents "works in dev, breaks in build"


value: aanesn

value: Show HN: Shorter: A domain shortener tool, written in Rust

author: aanesn


value: andybrummer

value:
I built an MCP server in Go that connects Libby (library ebooks/audiobooks), Hardcover (reading tracker), and Open Library (metadata) into one
   conversational interface through Claude.

  The problem: I use three separate platforms to manage my reading life. Libby for borrowing, Hardcover for tracking, and I had no single view
  of what I want to read next. Switching between apps to check availability, update status, or decide what to read was friction I wanted to
  eliminate.

  booklife-mcp exposes 27 tools over MCP stdio that let you:

  - Search your library catalog and place holds from a conversation
  - Sync returned Libby loans as "read" in Hardcover automatically
  - Maintain a unified TBR list across Hardcover want-to-read, Libby holds, Libby tags, and physical books
  - Get content-based recommendations using enriched theme/mood metadata
  - Check "what's the best way to read this?" (library availability vs. buy)

  Technical notes:
  - Go, single binary, SQLite for local cache
  - Hardcover via GraphQL, Libby via reverse-engineered OverDrive API, Open Library REST
  - Progressive disclosure pattern — tools return summaries first, drill down on request
  - Also ships as a Claude Code plugin with skills/slash commands

  GitHub: https://github.com/andylbrummer/booklife-mcp
  Docs: https://andylbrummer.github.io/booklife-mcp/

value: Show HN: Booklife-MCP – MCP server unifying Libby, Hardcover, and your TBR

author: andybrummer


value: I wanted to try out some products and tools like Lovable, Cursor, MCPs. So I built a dumb website to show how bad I am at sports gambling. Some thoughts in the linked blog. Site is here https://bets.bymitch.com/

value: Show HN: I built a dumb website using AI – Bets by Mitch


value: saysjonathan

value:
Hey, HN! With all recent agentic workflows being primarily terminal- and tmux-based, I wanted to share a little project I created about decade ago.
I've continued to use this as my primary terminal "window manager" and wanted to share in case others might find it useful.
I would love to hear about other's terminal-based workflows and any other tools you may use with similar functionality.

value: Show HN: Dwm.tmux – a dwm-inspired window manager for tmux

author: saysjonathan


value: Show HN: Agentic browser testing videos in GitHub PRs


value:
AdaL is the world’s first local coding agent with web UI.
Claude Code has proven that coding agents work best when they are local, bringing developers back to the terminal.
Terminal UIs are fast and great with shortcuts, shell mode, and developer-friendly workflows. But they are limited in history and image display, and the experience varies by terminal and OS. Many of them flicker (buuuut not AdaL CLI  ).
Most importantly, they can be quite intimidating for non-technical users.
This led us to explore new possibilities for a coding agent interface. What if you could get the best of both worlds:
- the same core local agent that does tasks exactly like AdaL CLI
- combined with a web UI with no limits on UI/UX
This can be especially powerful for design-heavy and more visual workflows
Available at: https://sylph.ai/

value: Show HN: AdaL Web, a local “Claude co-work” [video]


value: noanoanoa

value: Built this for those 3am moments when you remember something embarrassing from years ago. Write it down, bury it on a world map, and let strangers pay respects with . Part catharsis, part meme, part therapy.

value: Show HN: BuryIt – Bury your failures, regrets and secrets anonymously

author: noanoanoa


value: briskibe

value:
After my annual checkup showed LDL 4.4 mmol/L (170 mg/dL) and triglycerides
2.0 mmol/L at 33, I tried tracking with ChatGPT (lost data when context got
too big), then spreadsheets (too tedious).
Built a simple tracker focused on cholesterol. Log meals, see lipid breakdown,
track trends. I believe snacks and sugar were my main issue.
Stack: Angular 17 + NestJS + Supabase
Started January 1st, already lost 3kg. Same breakfast daily (psyllium, oats,
chia, skyr, whey, berries), cut sugar from daily to once per week.
Free during beta. Looking for feedback on whether strict diet cutting or 80/20
approach is more sustainable long-term.

value: Show HN: Cholesterol Tracker – Built after high cholesterol diagnosis at 33

author: briskibe


value: hpscript

value: Show HN: Flux, A Python-like language in Rust to solve ML orchestration overhead

author: hpscript


value: ufoym

value: Show HN: A simple algorithm for shifting solid-color image backgrounds (WASM)

author: ufoym


value: JoeyPro

value: Show HN: EchoDeck – A unified feed for RSS and Nostr to break information silos

author: JoeyPro


value: AlecMurphy

value: I noticed that Fabrice Bellard added x86_64 support to JSLinux, and I decided to do some work getting TempleOS up and running on it. Enjoy the fruits of my labor: TempleOS, running locally in your browser, completely unoptimized, with some convenient tools for debugging and playing around.

value: Show HN: TempleOS Playground

author: AlecMurphy

title: Show HN: TempleOS Playground


value: zero-lab

value: Show HN: ZTerm, a GPU-accelerated terminal emulator built with Rust and GPUI

author: zero-lab


value: xxayh

value:
I built Supe because I wanted Claude to analyze game binaries but not modify them. The constraints grew into something more general: a cognitive architecture for AI agents.
The problem: Most agent frameworks treat memory as flat storage. Store a key, get a value. That's not how useful memory works.
What Supe provides:
1. Neural Memory - Hebbian learning ("fire together, wire together"). Cards connected by synaptic links that strengthen with co-activation and decay with disuse. Spreading activation for recall. Hubs emerge naturally.
2. Validation Gates - Python functions that run before/after tool executions. Block `rm -rf`, enforce read-only mode, whitelist commands. Code, not configuration.
3. Proof-of-Work - SHA256 hashes chain every execution. Tamper with logs and proofs won't verify.
4. Cognitive Hierarchy - Moments (sessions) → Cards (knowledge units) → Buffers (raw data). Not flat.
5. Semantic Relations - 7 typed connections: CAUSES, IMPLIES, CONTRADICTS, SUPPORTS, DEPENDS_ON, EQUALS, TRANSFORMS.
Example gate:

  @agent.register_gate("safe")
  def safe(record, phase) -> GateResult:
      if "rm -rf" in record.tool_input.get("command", ""):
          return GateResult("safe", False, "BLOCKED")
      return GateResult("safe", True, "OK")

Example neural recall:

  neural.add_card(1, {"title": "OAuth"})
  neural.add_card(2, {"title": "Login"})
  neural.connect(1, 2)  # Hebbian learning
  results = neural.recall("authentication")  # Spreading activation

343 tests. MIT license. Works with Claude SDK.
pip install supe

value: Show HN: Supe – Give your AI agent a brain, not just memory

author: xxayh


value:
I built SonicJS because I wanted a headless CMS that runs natively on edge infrastructure without managing servers.
Key details:
- Runs on Cloudflare Workers (free tier works)
- Uses D1 (SQLite) for storage
- Built with Hono.js and Drizzle ORM
- REST and GraphQL APIs
- Admin UI included
- TypeScript throughout
The main goal was keeping it lightweight - the whole thing is under 150KB. No cold starts since it's on edge.
Been working on this for a while and recently added AI-assisted content schema generation which has been fun to experiment with.
Happy to answer questions about the architecture or Cloudflare Workers gotchas.

value: Show HN: SonicJS – open-source headless CMS built on Cloudflare Workers


value: fwttnnn

value:
Hi everyone,
libpgn was on ShowHN 2 years ago (https://news.ycombinator.com/item?id=41442029), I wrote this parser as an attempt to understand FFI (like what raylib does, how can other language understand C code?). It turns out there's no other C99 implementation for a .pgn parser (aside for some C++ library), which was a golden opportunity.
What can you do with libpgn?

    - Make a replay system (barebone in Ada: https://github.com/user-attachments/assets/8d30cdc3-7692-45bc-b313-db19e981529c).
    - Save a game state, so you can reproduce the same state if it crashes.
    - Chess game/opening/tutorial database.
    - Feed neural networks to play chess from .pgn record?
    - And, more ..?

I recently compared libpgn with `python-chess` (RegEx), and it shows to be 66x times faster (https://gist.github.com/fwttnnn/ad0f60d37ef9e8fefdd0c8664f18...).
Also, libpgn was originally GPLv2 (https://news.ycombinator.com/item?id=41442199). Since this was a library, I just decided to switch into ISC.

value: Show HN: Libpgn – .pgn (chess game records) parser, 2 years later

author: fwttnnn


value: alepeak

value:
Hi HN, founders of VibeFlow (YC S25) here.
We mostly work on backend and workflow tooling, but we needed a way to turn Figma designs into frontend code as a kickstart for prototyping.
It takes a Figma frame and converts it into React + Tailwind components (plus assets).
If you want to try it:
You can run it locally or use it via the VibeFlow UI to poke at it without setup (https://app.vibeflow.ai/)

value: Show HN: Open-source Figma design to code

author: alepeak


value: Zenith-Software

value: Show HN: Directory of 1000 open source alternatives to popular software

author: Zenith-Software


value: chaitanyya

value: Tried all SaaS Sales and GTM tools; ended up vibe-coding a simple tool that just works. Uses Claude Code as a backend (funny, I know). Helps enrich, qualify, and prepare high-quality reach-outs

value: Show HN: Claude Code for Sales and GTM

author: chaitanyya

title: Show HN: Claude Code for Sales and GTM


value: abalol

value: Show HN: Gmn – A lightweight Gemini CLI in Go (68x faster startup)

author: abalol


value: Show HN: A self-hosted collaborative viewer for pathology slides (Rust, WebGL2)


value:
Hi HN, I built Orbit to solve a visibility gap in AI cost management.
Provider dashboards show aggregate API spend, but don't answer which product feature is driving it. When your bill spikes, you're left guessing whether it's the chatbot, document processor, or an agent workflow running inefficiently.
Orbit attributes every LLM call to a specific feature, task, or customer. You wrap your existing AI client with our SDK, tag calls with metadata, and get real-time dashboards showing cost, latency, and error rates broken down by feature.
Key capabilities:
Per-feature cost and performance attribution
Agentic workflow tracking (group multi-step LLM calls by task or customer)
Support for OpenAI, Anthropic, and Gemini
SDKs for Node.js and Python
One-line integration, no API key access required
Free tier available.
Why I'm showing this now: I’m looking for 5-10 "Design Partners" to break the SDK and tell me what’s missing. I'm especially interested in teams building complex agents who feel they've lost control of their token spend.

value: Show HN: Orbit – Track "zombie loops" and cost-per-feature in AI agents


value: yeeyang

value:
I wanted to build an army of AI agents that create valuable content with taste. But I had zero experience building this kind of product.
So I chose to learn by cloning Typefully – a Twitter scheduling tool I actually use and love. Built entirely with Claude Code over 3 months.
-----
What I learned:
Vibe coding hits a wall with performance problems. The details Typefully polished? That's where the real craft lives. Copying taught me to see what I'd otherwise miss.
Where I'm going differently:
- Firstly , I built an "Influencer Finder" that analyzes lists to discover valuable creators
- Second,I downloaded their tweets by the tool I built called twitter advanced search ,and extract content pillars, writing techniques, and voice patterns via Claude
- At last,I packaged these as Skills to create agents that write in your style and values
Tested it on my own tweets first. Results were surprisingly good.
And Now I am still building this knowledge base for agents.
Target users:
Founders and one-person teams who need to build personal + product brands through social media writing.
-----
It started as a copycat. It won't end as one.
Happy to answer questions about what I learned or where this is heading.
And here's the Product:
https://xaicreator.com

value: Show HN: 3 months cloning Typefully with Claude Code – here's what I learned

author: yeeyang


value: keepamovin

value:
After 3+ years of heavy agentic coding, I noticed a pattern: Claude/Cursor/Copilot generate code that works but doesn't belong.
It passes tests. It runs. But it fights the grain of the language. It invents state when the platform provides it. It hides causality behind clever one-liners. It creates three different solutions to the same problem in the same file. The architecture is technically valid but cognitively expensive.
Prompting for "clean code" didn't help. The agents needed what I'd give a talented junior: a handbook on taste.
So I wrote doctrine files—markdown constraints that teach agents the difference between code that compiles and code that's maintainable. Things like:
- "More than 20 mutable state variables in a file? You have multiple modules pretending to be one."
- "Three approaches to the same problem coexisting? Pick one, delete the others."
- "If you can't explain the condition in one sentence, extract it to a named boolean."
AI Lint is the productization of this. It's not a CLI or SaaS—just optimized text files you drop into .cursorrules, AGENTS.md, or your system prompt. The agents read them and actually follow them.
There's doctrine (what belongs) and rejects (what to refuse). When rules conflict, there's an override protocol. It's designed for context injection, not human reading.
Business model: Paid packs for different stacks (Apps, Systems, etc). But I've released a free preview on GitHub with the core philosophy and JavaScript/Node.js doctrine so you can test the impact.
- Website: https://ai-lint.dosaygo.com
- Free Preview: https://github.com/DO-SAY-GO/AI-Lint
Curious what anti-patterns AI keeps injecting into your codebases. I'm expanding the Go and Rust rejects right now, and planning iOS/Swift and infra (Docker, k8s) packs next.

value: Show HN: AI Lint – Teach coding agents your team's standards, not just syntax

author: keepamovin


value:
I built this because measuring my age in years felt boring—I wanted to see the kilometers.
The first version only used Earth's orbital speed (~30km/s), but the number moved too slowly. To get the "existential dread" feeling, I switched to using the Milky Way's velocity relative to the CMB (~600km/s). The math takes some liberties (using scalar sum instead of vector) to make the speed feel "fast," but it gets the point across.
Under the hood, it's a single HTML file with zero dependencies. No React, no build step. The main challenge was the canvas starfield—I had to pre-allocate the star objects to stop the garbage collector from causing stutters on mobile.
Let me know if the physics makes you angry or if the stars run smooth on your device.

value: Show HN: I built a space travel calculator using Vanilla JavaScript


value: Show HN: Jar.tools – online Jar file opener


value: tamnv

value: Show HN: Free AI Headshot Generator

author: tamnv

title: Show HN: Free AI Headshot Generator


value: Lwrless

value: Show HN: Vibecoded AWS SAA‑C03 Cheat Sheet

author: Lwrless


value: Show HN: Heterogeneous Agent Protocol (Derived from Nursing and Construction)


value: lincyang

value: A searchable directory of 50+ AI roleplay characters with advanced filtering

value: Show HN: Character AI Bots Directory

author: lincyang

title: Show HN: Character AI Bots Directory


value:
It was created with the aim of serving LLM models on consumer hardware, with a focus on portable machines. The basic concept is to optimize inference on integrated iGPUs, with excellent results. The project is open source, and you can take a look.
It was created with a Rust backend, Flutter frontend, and llama.cpp as the inference engine.
There is currently full support for macOS with silicon chips, and for Windows with Vulkan, which has a broader base of hardware it can handle.
RAG has been implemented
and web search is currently available.
But the project is alive and other new implementations will gradually be made.
I'll leave you the website where you can download it, as well as the GitHub page.
https://resourceai.fenixresource.com
https://github.com/orgs/ResourceAI-app/repositories

value: Show HN: ResourceAI – Local LLM inference optimized for consumer iGPUs


value: When robot navigation scales from hundreds of meters to several kilometers, managing waypoints as raw numeric values quickly becomes painful and error-prone.<p>This provides a GUI tool that lets you visually edit waypoints on a map, automatically generate them from start and goal positions, and batch-edit multiple waypoints at once, making medium- to large-scale navigation much easier to manage.

value: Show HN: I built A GUI for managing waypoints in large-scale robot navigation


value:
Hey HN,
I've struggled with time-blindness my whole life. ADHD means I can write 14 tasks on a to-do list and genuinely believe I'll finish them before lunch. Reality disagrees at 11 PM when everything falls apart.
DayZen is my solution: your day as a 24-hour radial clock. Tasks become colored arcs. When the circle fills up, it's full. No more lying to yourself about what actually fits.
Just shipped 1.4 with Focus Mode
The new version adds features I've wanted since day one:
Focus Mode: Full-screen timer that zooms into your current task. Distractions fade, simple controls keep you on track. Built it because I kept checking my phone to see "what's next" and losing 15 minutes to Reddit.
Live Activities + Dynamic Island: Your active focus session shows on Lock Screen with time remaining and progress bar. Sounds simple, but it's been genuinely game-changing for staying aware without pulling out my phone.
Insights: Added analytics (today/weekly/monthly/yearly) with streaks and category breakdowns. Turns out I spend 40% of my time on "Important but not urgent" which explains a lot.
Time awareness improvements: Specifically designed for ADHD time blindness. Visual feedback makes abstract time concrete.
Why a radial clock?
Linear lists hide the finite nature of your day. They feel infinite, so you keep adding tasks. A circle forces honesty. Conflicts glow red immediately. You see gaps. You make the hard choices before the day starts, not at midnight when you're burned out.
Technical details:
Built native iOS with SwiftUI
Two-way calendar sync (Google, Outlook, Apple)
Local-first, iCloud sync between devices
No account needed, no tracking, no ads
Lock Screen widgets use WidgetKit with Live Activities API
Recurring tasks auto-generate instances for next 30 days
Privacy approach:
Your schedule stays on your device. I don't collect, sell, or see your data. No analytics, no crash reporting, no server calls except calendar sync (which uses system auth). This was non-negotiable for me as both an ADHD person and someone who values privacy.
Looking for feedback on:
Does the radial approach click for you, or is it too different?
Focus Mode UX: Does the minimalism help or is it too minimal?
What other time-blindness features would help?
Try it: https://www.dayzen.xyz/
Site:Happy to answer questions about the technical implementation or design decisions. Built the whole thing solo over the past year while working full-time, so there are definitely rough edges I'm still smoothing out.

value: Show HN: DayZen: Visual day planner for ADHD brains


value: Anshikakalpana

value:
I'm a 2nd year student building ReTraced — a distributed job scheduler
that treats retry behavior as first-class data instead of hiding it in
logs or config flags.
Most schedulers tell you a job retried 3 times. ReTraced tells you:
- When each retry happened (with timestamps)
- Why it retried (transient failure vs permanent)
- Was it automatic or manually triggered?
- Full audit trail before DLQ
I built this because while stress-testing, I found a backoff timing bug
that only showed up when I could see retry attempts as structured data.
Expected exponential delays (5s → 10s → 20s), but actual timestamps showed
~6s plateaus. The visibility made debugging trivial.
*Core ideas:*
- Retry attempts stored as queryable records (not just counts)
- Per-job retry strategies (fixed, linear, exponential + jitter)
- DLQ is first-class with full failure context
- Redis-backed, at-least-once semantics
*Current state:* v1.0.0 — core model stable, usable for internal tools
and experimentation. Goal is production-ready self-hostable within a year.
I'm actively looking for feedback on:
- DLQ replay strategies
- Redis coordination patterns vs Postgres
- Retry strategy edge cases I'm missing
GitHub: https://github.com/Anshikakalpana/ReTraced
Docs: https://re-trace-five.vercel.app/
Would love your thoughts, especially from folks who've built or operated
schedulers in production.

value: Show HN: ReTraced – Job scheduler that makes retries visible as data (v1.0)

author: Anshikakalpana


value: thamiltonsmith

value: Show HN: A project planning tool designed around drvleopers

author: thamiltonsmith


value: Show HN: Giving Claude Code "hands" to deliver local files (P2P, No Cloud)


value: DeployToProd

value: Show HN: Turn photos into buildable brick mosaics with build instructions

author: DeployToProd


value: e-clinton

value: Show HN: Browser MCP for the Terminal

author: e-clinton

title: Show HN: Browser MCP for the Terminal


value: Show HN: RWS – Local-first task orchestrator using Qwen 2.5 on consumer hardware


value:
I built a WhatsApp agent that verifies whether forwarded content is real or fake.
The problem: My parents and family keep getting increasingly sophisticated scam messages—fake traffic violation notices with convincing phishing links, AI-generated videos, "digital arrest" calls. They're not careless; the fakes are just good now.
How it works: Forward the suspicious message/image/video to the bot → get an instant breakdown of red flags (fake domains, AI-generated media, impersonation patterns, etc.)
Stack:
Meta WhatsApp Cloud API
Claude for orchestration
Gemini 3 Flash for content analysis
Sightengine for AI image detection
Modular architecture for swapping detection providers
Targets ~2-4 second response time for new content, sub-second for cached.
The tricky part was balancing false positives—flagging legitimate content as fake would destroy trust faster than missing actual scams.
Try it for free: www.kaval.chat
Would love feedback, especially on detection edge cases. Happy to answer questions about the architecture.

value: Show HN: Kaval – WhatsApp agent that checks if content is real or fake


value: hejinhui

value:
Hi HN — I built a small browser-only “random decision” toolkit for classrooms/events/office raffles.
Link: https://roulette-tool.online/
What it does: pick winners from a pasted list, spin a roulette, decide an order, split teams, roll dice, flip a coin.
Key details:
Uses the browser’s cryptographic RNG (Web Crypto) for fairness
No login / no email — data is processed locally on the device
Mobile-first UI, plus fullscreen mode for projector use
One-tap copy of results
I’d love feedback on: (1) usability on mobile, (2) any confusing wording, and (3) feature requests (e.g., weighting, history, shareable links).
Note: the UI is currently Japanese-first; if that’s a blocker, tell me and I’ll prioritize an English toggle.

value: Show HN: A free, no-login random decision toolkit (roulette, teams, order, dice)

author: hejinhui


value: mrbutttons

value:
TLDR:
AI agents brute-force their way through codebases with grep/find/glob to understand it. This CLI queries a local SQLite database of your codebase's dependency graph instead, giving agents accurate context for better plans on the first try.
I've been using Claude Code for my work for the past 6 months and it has been great. My workflow is very typical, start Claude Code > start planning my feature in plan mode > implement. And then just seeing the work, and occasionally steering it in the correct direction when it goes off track (which doesn't happen much).
But since Claude Code has amnesia and you can only put so much in your CLAUDE.md file, it always ended up brute forcing its way around the codebase to understand it first. Usually by picking an entry point first somehow and then walking up.
So I ended up building this, a simple CLI meant to be used by your AI agent, that you can drop in any project (as long as your language has a SCIP indexer).
It uses SCIP to index your codebase, and then the CLI converts it into a SQLite database. All commands are just wrappers around the queries, and you can just query the database directly. SCIP does not really work for documentation and general text files, I added an indexer for that in the CLI (this one is a bit wonky, I recently added it)
To set it up it:
1. Install the CLI in your system.
2. Install the SCIP indexer for your language.
To start using it in project:
1. Add the snippet in your agent memory file to tell it to prefer dora instead of other tools when doing code exploration.
2. Add the skill file for more detailed usage.
3. Add hooks to run the indexer at session start and at end of every turn, in the background.
I've been using it with my main work, and tweaking it as I find room for improvements. The idea is to keep it minimal. I'm able to get good plans on the first go.
Check it out:
Website - https://dora-cli.dev/
GitHub - https://github.com/butttons/dora

value: Show HN: Dora – Query codebase dependency graphs from SQLite (for AI agents)

author: mrbutttons


value: yz-yu

value:
AI agents often need domain-specific knowledge to complete tasks. Rather than writing custom prompts or building MCP tools from scratch, leveraging existing API documentation is a practical approach - and OpenAPI is the de facto standard with battle-tested specifications maintained over years.
However, feeding raw OpenAPI specs to agents has limitations. Complex specifications can exceed LLM context limits, and even when they fit, loading the entire document for every request wastes valuable context.
Agent Skills solves this by structuring documentation for on-demand reading. Agents load only what they need - starting with an overview, then drilling into specific operations or schemas. Since file reading is a universal capability across agent frameworks, this approach works everywhere without special integrations.

value: Show HN: Convert OpenAPI Specifications into Agent Skills

author: yz-yu


value: nawouda

value:
Hi HN! We built PyVRP, an open-source solver for vehicle routing problems.
It can solve many practical routing problems, including those with time window constraints, multiple depots, and reloading. These problems all NP-hard, so PyVRP implements a state-of-the-art metaheuristic solver based on iterated local search. The local search optimisation engine is written in C++. On top of the solver, PyVRP exposes a high-level Python modelling interface. This makes it easy to solve large-scale routing problems from Python, at near-native speeds.
Docs: https://pyvrp.org/

value: Show HN: PyVRP, an open-source vehicle routing problem solver

author: nawouda


value: notcalc

value:
Hi HN,
I built cook.nvim, a Neovim plugin to run or compile the current file in a terminal, based purely on file extension and config.
Instead of baking language support into the plugin, runners are just shell command templates with placeholders ({file}, {exe}, {dir}, etc.), so it works with almost any language or toolchain without plugin changes.
It also supports project-local recipes.lua for things like :Cook build, :Cook test, or custom workflows, plus a small :Coop mode that pipes clipboard input into your program (useful for competitive programming).
Repo: https://github.com/07CalC/cook.nvim
Feedback welcome.

value: Show HN: Cook.nvim – an extensible code runner for Neovim

author: notcalc


value:
Just released v0.9.1 of afm, a CLI that exposes Apple's on-device Foundation Models through OpenAI-compatible API endpoints.
What's new in v0.9.1 - Built-in Web UI:
Links:
GitHub: https://github.com/scouzi1966/maclocal-api
Release: https://github.com/scouzi1966/maclocal-api/releases/tag/v0.9...
You can now run afm -w to start both the API server and a chat web interface in one command. It integrates llama.cpp's webui and auto-opens your browser. No need to set up Open-webui separately if you just want a quick chat interface.
afm -w
That's it. Browser opens to http://localhost:9999 with a chat UI talking to Apple's on-device 3B model.
Other changes:
/props endpoint for webui compatibility
model field now optional in chat completion requests
llama.cpp pinned as a submodule for reproducible builds
What afm does:
Runs Apple's 3B parameter on-device LLM
OpenAI-compatible API (/v1/chat/completions, /v1/models)
Single-prompt mode: afm -s "your question"
Pipe mode: cat file.txt | afm
LoRA adapter support for fine-tuned models
Vision capabilities (text extraction, table OCR)
Works as a backend for Open-webui too
Install:
brew tap scouzi1966/afm
brew install afm
Requirements:
macOS 26 (Tahoe)
Apple Silicon (M1/M2/M3/M4)
Apple Intelligence enabled
Questions welcome.

value: Show HN: Afm – explore Apple's On device model. Now with WebUI


value:
Gitmore (https://gitmore.io) – makes Git activity accessible to people who don't use Git. Every commit has a message. Every PR has a title and description. The status update already exists. It's just locked in GitHub.
Who this is for:
- Founders updating investors - PMs writing release notes - CEOs who want visibility without standups - Anyone who asks "what shipped?" and waits for an engineer to respond
What it does:
Connect your repos. Ask questions: - "What shipped this month?" - "Who worked on the billing feature?" - "Which PRs are stuck?"
Or schedule automated reports to Slack or email. Weekly, monthly, whatever.
How it works:
We register webhooks. Git platforms push event metadata – commit messages, PR titles, descriptions, authors, timestamps, file counts.
Every event gets normalized into a structured schema. The AI queries structure, not raw text.
What we don't do:
We don't do code review. We don't analyze diffs. We don't compete with Coderabbit or Greptile. Those are for engineers inside the PR workflow.
This is for people outside that workflow who need visibility.
Security:
Webhooks only. We never clone repos or access source code.
- Token encryption: Fernet (HMAC-SHA256 + AES-128-CBC) - Webhook verification: HMAC-SHA256 - 2FA support
Works with GitHub, GitLab, and Bitbucket.
Free for 1 repo: https://gitmore.io
How do non-technical people at your company stay informed on dev progress?

value: Show HN: Ask your repos what shipped in plain English


value: stevekrouse

value: With the rise in vibe coding and an influx of new programmers, I think it's important that we teach folks the critical debugging skills – both for them to solve their own problems, and for us to get reasonable bug reports!

value: Show HN: repro.fyi – a guide on making minimal repros

author: stevekrouse


value: erikpau

value: Hi all, I always missed having an image editor in  the Jetbrains products (PyCharm, Webstorm, IntelliJ), so I built a plugin to handle most image editing capabilities. Also added Gemini and OpenAI support, which lead to some surprising capabilities.<p>Not gonna lie, took a while to build, even with AI tools, and I have a long list of features to add, but I'm super happy its on the market place now, and I even did a first sale, and I'll probably never be able to express how happy that made me!

value: Show HN: Built an AI powered image editor for IntelliJ

author: erikpau


value: mikeayles

value:
Third entry in my series of running DOOM on engineering tools that weren't designed for games.
KiDoom rendered walls as PCB traces in KiCad. ScopeDoom piped vectors through a headphone jack to an oscilloscope. Now OpenSCAD-DOOM exports geometry to a parametric CAD tool in real-time.
It's a custom Python engine that reads WAD files and outputs OpenSCAD code. Pygame handles input and runs a parallel software renderer. The OpenSCAD side uses Animation mode to bypass the file watcher's 200ms debounce.
I actually started this in December intending to release it at Christmas, but couldn't get the performance above slideshow levels. Parked it. Then last week I had to fix OpenSCAD rendering for another project and discovered the npm openscad-wasm package was from 2022 and silently ignoring the Manifold flag. The fix (https://phaestus.app/blog/blog0031) took renders from 2 minutes to 2 seconds. Rolled that back to OpenSCAD-DOOM and suddenly it was playable. (FYI, the mainline version of openSCAD is 2021.01!)
Blog post: https://www.mikeayles.com/#openscad-doom
Code: https://github.com/MichaelAyles/openSCAD-DOOM
YouTube: https://youtu.be/l9nnV-mO4wY

value: Show HN: Doom running in OpenSCAD at 10-20 FPS

author: mikeayles


value: sugaiketadao

value:
Hi HN,
I've been working on SICore, a lightweight Java web framework designed for two audiences: programming beginners and AI coding assistants.
Unlike feature-rich frameworks like Spring, SICore removes annotations and complex configurations. Here are some core design choices:
• URL = Class name – No routing config needed. `/services/example/UserSearch` directly maps to `com.example.services.example.UserSearch`.
• JSON-centric – Browser-server communication is JSON only. HTML files are static; no template engines involved.
• AI-native – Includes `.github/copilot-instructions.md` so AI coding assistants understand framework conventions.
• Traceable – Entire framework is fully open source, making execution flow easy to follow for humans and AI.
It also includes a small custom CSS library, robust `Io` class for NULL-safe data handling, and standardized UI/business logic patterns that help AI generate accurate code.
In tests with Claude Opus 4.5, it generates complete screens (HTML/JavaScript/Java) from requirement documents. Core features work well though still under development.
Try it yourself:
• Sample screens (VS Code): https://github.com/sugaiketadao/sicore#%EF%B8%8F-how-to-veri...
• AI development guide: https://github.com/sugaiketadao/sicore#-getting-started-with...
I'd love feedback, especially on the AI-assisted development approach!
GitHub: https://github.com/sugaiketadao/sicore

value: Show HN: SICore – Lightweight Java framework for beginners and AI codegen

author: sugaiketadao


value: Show HN: MetaPurge – Strip metadata and timestamps from images/PDFs


value: gewing

value:
Stratis is a customized, AI advisory of historic characters who help flight-test ideas, brainstorm solutions, and analyze problems.  Stratis advisors are available 24/7 and are the perfect first stop to assess ideas in a judgment-free environment.  The goal is to sharpen your ideas so that you're ready to share them with your co-founders, team, board, and the world.
We started this project because we've experienced the extreme value of external advice and candid feedback.  Generic AI systems optimize for the average without ethical memory or any effort to draw out your unique perspective.
We are just launching the MVP of the Stratis advisory and are looking for early users and any and all feedback.
Try for free with code:  HNFREEMONTH

value: Show HN: AI Advisory Board

author: gewing

title: Show HN: AI Advisory Board


value: yelabbassi

value: Show HN: PhantomMusic – Neural spiking data transformed into music

author: yelabbassi


value: kevinbaur

value:
I built GitPulse (https://www.gitpulse.dev) to visualize development velocity for private repositories.
It generates a password-protected dashboard showing your commit graph, shipping streaks, and project status (Active vs. Stable) using only metadata.
Useful if you need to prove a private project is alive (e.g. for acquisitions or clients) but don't want to leak your source code.

value: Show HN: Share private Git repo activity without granting code access

author: kevinbaur


value: threekindwords

value:
I built this over the holiday break with my two girls (ages 6 and 8). You pilot a UFO and beam up humans, cows, cats, dogs, and sheep for points. They drew all the art while I talked to Claude Code to scaffold the game logic.
The magic moment was watching my kids use voice dictation to talk directly to Claude Code. My 8-year-old asked for a "purpler" tractor beam and watched it change in real time. She wasn’t coding, but she _was_ driving: describing what she wanted, testing the result, and iterating fast. It was really cool to watch... later on she asked me what javascript was and we dug into the source.
Since then we've added a UFO Shopping Mall between waves (spend UFO bucks on power-ups), bombs, laser turrets, a dodge roll called "warp juke," and a top 100 leaderboard. There's also in-game feedback where you can submit and upvote feature requests. Building all these little features has been a great excuse to put in reps with AI coding tools and try out new stuff like Gastown.
You'll need a desktop and keyboard to play. Try to beat my high score! Would love feedback on what to add or what's broken... we'll ship the best suggestions. Thanks and have fun!

value: Show HN: Alien Abducto-rama: a FUN browser game I made with my kids

author: threekindwords


value:
HyperAI built a leaderboard that compares GPU performance metrics specifically for machine learning and AI workloads.
URL: https://hyper.ai/gpu-leaderboard
It shows up-to-date hardware specifications and benchmark figures (e.g., FP16/FP32/FP64 performance, memory bandwidth) for a variety of modern GPUs. The goal is to help researchers, engineers, and practitioners understand how different GPUs stack up for ML/AI use cases.
Key features
* 29+ GPUs with detailed hardware specs
* Side-by-side performance comparison across FP types
* Focused on AI/ML workloads rather than gaming
Would love feedback on the layout and utility — especially from folks who do GPU benchmarking or care about hardware trade-offs in AI workloads.

value: Show HN: HyperAI GPU Leaderboard – A benchmark comparison site for AI workloads


value: keepamovin

value:
I've been using this thing I made called "AI Lint" it's a collection of doctrine, ant rejected anti-patterns that I noticed agents both failing to use and overly leaning into.
It's also general patterns for debugging, and architecture to help agents manage complexity in large codebases.
It's kind of cool to watch Codex say: "Also, to dig in, I need to follow the repo’s AI Lint rules first. I can start reading those and then inspect the recent changes. Do you want me to proceed?"
These are non-syntactic, non-mehanical, opinionated senior engineering wisdom that is tailored to specific languages and frameworks, won of experience, and aiming to let the AI simulate an senior architect's "taste", rather than just hammering away until code "basically works".
The problem of AI spaghetti code is real, and it's easier to embed some hard doctrine and rejects into the repo that agents must follow to prevent their nonsense (and reduce time to target) than it is to fix their problems later.
Been there, done that. Now I built AI Lint. And it's yours too. For a fee, but there's a free taster to get the idea: AI get syntax fluently, but they don't readily pick up the "grain" of a language.
I'm proud of the name I think it really resonsates and captures what this is both "lint for AI" but also "AI-native lint" that leans into their strength of complex nuance understanding and task following, while patching their weaknesses for really bringing the right solutions to bear at the right time in compelx situations.
The paid version also has sections for secrets security, a guide on how to author your own doctrine that AI will follow, and an override protocol you can use to resolve conflicts between conflicting doctrine (it's all tradeoffs), or just override the lint for your own team's taste.
On the whole agents are needed and going to be here. In the meantime I think domain specific context-boosting like this, and super precise tooling to let them quickly jump to tasks while retaining contextual clarity is going to be two (among many) huge levers. For now, AI still lack what senior devs bring to the table - depth, wisdom, and great design/arch instincts -- but senior devs can't work as fast, unaided, as an AI can. So it's better to figure out a way to work together optimally. As there's no point using an AI that makes subpar work you have to redo. AI Lint is a small, hopefully useful, step in that direction.
I hope you will try it, find value in it and pay for it, and support its future development by staying on board as new packs land for additional language, frameworks and useful domains.
AI is strong, but judgment is orthogonal, and still in short supply - but now with AI Lint it's transferable.
Check it out! https://ai-lint.dosaygo.com :)

value: Show HN: AI Lint your agents work to build faster and better

author: keepamovin


value: boomzors

value:
Hello, everyone,
I've been trying to keep track of my finances, but I guess I'm too lazy for budgeting apps. At the end of the day, I just want to know if numbers go up or down. To fix this, I've built an app that allows me to add snapshots from my banks and assets to get an overview. I've been using it for months and it's been great, so I've decided to improve its appearance and publish it.<p>This app has no tracking or in-app purchases. Buy it once and use it on your iPad, iPhone, or Mac. I'm planning some cool features for the future, like Apple Intelligence support.
I hope you like it. Thanks

value: Show HN: Bread Count – Private Net Worth Tracker

author: boomzors


value: lakshikag

value:
Hey everyone, two of us have been working on a privacy-focused Discord alternative for some time and we’re opening it up for early testing to see how it performs and to get real feedback.
Kloak is privacy-first by design. There are no emails and no passwords. When you join, you’re given a secret key, and that key is your account. There is no recovery mechanism and no central identity tied to you. If the key is lost, the account is gone. This is intentional and meant to reduce stored user data and avoid creating identity honeypots.
Most of the core features are already in place. You can create servers, channels, roles, and permissions, upload files and custom emojis, etc.
We’re still early, and the main goal right now is to validate the model, catch UX issues, and stress the system a bit before going further. We’re especially interested in thoughts around the key-based account approach and any privacy or security trade-offs we may be overlooking.
If you’re curious or want to poke at it, it takes only a few seconds to join and doesn’t require any personal information. You can join Kloak at https://kloak.app
Feel free to join our official server too through https://kloak.app/invite/PV3FEB8N

value: Show HN: Kloak – a privacy-first Discord alternative with no email or passwords

author: lakshikag


value: exos-xyz

value:
I run a UI design agency.
Last month I was building a client project in Cursor.
The output looked... fine.
Same rounded corners. Same blue buttons. Same "AI-coded" vibe.
Every project was starting to look identical.
The problem? AI has no design context. It defaults to the same generic patterns.
So I built PromptUI for myself.
Now before any client project, I:
Paste a URL that matches their brand vibe
Extract the full design system (colors, typography, spacing, components)
Feed it directly to Cursor or Claude Code
Result: Client-ready UI. First try.
No more "make it look more premium" back-and-forth.
$19 once. 20 exports. No subscription.
I use it daily. Maybe you will too.

value: Show HN: PromptUI – AI kept giving me the same boring UI. So I fixed it

author: exos-xyz


value: yelabbassi

value: Show HN: PhantomLoop – Real-time BCI decoder visualization in the browser


value: sepositus

value: Show HN: Supply chain security for everything that isn't a container

author: sepositus


value: actfrench

value: Modulo is a place to find vetted homeschooling resources: curriculum, tutors, classes and connect with other tech-savvy families who are doing homeschooling, modular learning, unschooling or curating their children's education as a supplement or replacement to traditional school. We've curated a collection of over 2000 resources vetted by hundreds of homeschool parents to ensure they're accurate, secular, evidence-based and engaging for kids. Our AI-powered learning concierge can make specific recommendations based on children's learning profiles and special needs such as "find me an engaging 6th grade science curriculum for a kid with ADHD who loves YouTube." or "I need an amazing hands-on math program for a profoundly gifted 2nd grader flailing in private school."

value: Show HN: Modulo – homeschooling resources, community and expert support

author: actfrench


value: logicalsam

value:
Hey HN!
I built a tool which I'm excited to share with you, and hopefully you'll see why!
The problem I had in my own business: there was never a _right_ tool to request secrets from my customers. I needed router configs, env variables, API tokens, you name it. I had a password manager but that wasn't the right fit to request client secrets and left much to be desired.
My aim:
1. SaaS which isn't ridiculously expensive
2. Which doesn't have any knowledge of your secrets
3. Which keeps the user experience straight-forward
4. Which cannot have any knowledge of your secrets
5. Which lets you automatically remove secrets which aren't needed anymore
6. Which lets your clients remove secrets which aren't needed anymore
7. Which doesn't duplicate the goal of a traditional Password Manager
8. Make it Tech Service Industry-friendly (MSPs, IT Agencies, & more)
And so I built a thing (hooray!):
Introducing: keyhold.io - zero-knowledge custody of secrets.
With keyhold.io, you can request clients share client-specific or project-specific secrets, grant access to your team to view specific secrets, and rest well knowing that even if the service got pwned, your secrets aren't out in the open. Be it .env, TLS certificates, config files, you name it, you can share it.
£50 per month or £500 per year - no per-seat fees. Priced based on estimated usage with only soft limits in place to prevent any abuse.
I'd love to hear your thoughts on the concept, and welcome anyone to give it a shot!
Cheers,
Samuel, Founder @ keyhold.io

value: Show HN: Keyhold.io – zero-knowledge custody of secrets [that aren't yours]

author: logicalsam


value: DurhamSmith

value:
I've been using Manim for educational content recently and wanted natural-sounding voiceovers without cobbling together external tools. When Qwen3-TTS got open sourced, I built a plugin to integrate it with manim-voiceover.
It supports all three Qwen3-TTS generation modes:
- Voice Cloning — Clone any voice from a 3+ second audio sample
- Voice Design — Generate voices from text descriptions (e.g., "a warm, elderly British woman speaking slowly")
- Preset Voices — 9 built-in speakers with emotion/style control via an instruct parameter
Basic usage looks like:
from manim import *
from manim_voiceover import VoiceoverScene
from manim_voiceover_qwen3_tts import Qwen3PresetVoiceService
 class MyScene(VoiceoverScene):
    def construct(self):
        self.set_speech_service(Qwen3PresetVoiceService(speaker="Ryan"))
         with self.voiceover(text="Let's draw a circle") as tracker:
            self.play(Create(Circle()), run_time=tracker.duration)
Runs locally, ~4GB VRAM for the 1.7B models (0.6B models available for lighter setups). Supports 10 languages. Audio is cached so re-renders are fast.
GitHub: https://github.com/DurhamSmith/manim-voiceover-qwen3-tts
Happy to answer any questions.

value: Show HN: Qwen3-TTS integration for Manim animations

author: DurhamSmith


value: flymartin

value:
Hello HN,
I built Rdytofly because the modern travel planning experience is fragmented. You usually need at least 5 different apps just to organize one trip (Maps for location, Shared Docs for logistics, WhatsApp for collaboration, Notes for packing, etc.).
I wanted to consolidate this chaos into a single "Travel OS".
It is designed to handle the full lifecycle of a trip:
*  Logistics Automation: Handles time zone shifts, flight numbers, transfers, and layovers automatically.
*  Visual Planning: Drag & drop itinerary builder directly on a map.
*  AI Inspiration: Use the AI section to find top spots or hidden gems based on your input, then add them to your plan.
*  Collaboration: Real-time editing with friends (replaces shared docs).
*  Journaling: Keep a travel diary linked to specific days/locations.
*  Offline Backup: One-click export to a detailed PDF guide.
Pricing:
It’s 90% free. You can plan full trips, use the map, and export PDFs without paying. The Premium features (AI generation, advanced expense tracking) cost about the price of a coffee.
I'd love to hear if this successfully replaces your current stack!

value: Show HN: Rdytofly is an all in one travel helper replacing multiple apps

author: flymartin


value: vassilbek

value: Show HN: Turn Raw Fitness Data from Garmin/Apple into Clear Coaching Insights

author: vassilbek


value: zealer

value:
I've updated Encrypter.site with a new Time Capsule feature. It lets you "seal" a message that is mathematically impossible to open until a specific date and time you choose.
It's built on top of the Drand network, ensuring that there is no central authority holding the keys. No sign-up required, zero server-side storage of your data.
Try it out and let me know what you think.

value: Show HN: Send encrypted messages to the future (Client-side Time Capsules)

author: zealer


value: fcpguru

value:
Working from home? Are you a remote employee that "misses" going to the office?
Well let's be clear on what you actually miss. No one misses that feeling of having to go and be there 8 hours. But many people miss friends. They miss being part of a crew. Going to lunch, hearing about other people's lives in person not over zoom.
Join a co-working space you say? Yes. We have. It's like walking into a library and trying to talk to random people and getting nothing back. Zero part of a crew feeling.
https://dialtoneapp.com/
This app helps you find a crew and meet up for work and get that crew feeling.
This is my first time using cloudflare workers for a webapp. The free plan is amazing! You get so much compare to anything else out there in terms of limits. The sqlite database they give you is just fine, I don't miss psql.

value: Show HN: Remote workers find your crew

author: fcpguru

title: Show HN: Remote workers find your crew


value:
Hi HN, I’m the author of Loclean.
I built this because I work with sensitive data that I can't send to OpenAI, but traditional tools like Regex were too brittle for the messiness of real world inputs (like address typos or inconsistent date formats).
Loclean is a Python library that:
- Runs entirely locally (CPU friendly) using quantized models via llama-cpp-python.
- Uses Pydantic to enforce strict schemas (no more hallucinations or invalid JSON).
- Compatible with Pandas/Polars/PyArrow workflows.
It's designed to be a "middle ground" between rigid Regex and expensive/risky Cloud LLMs.
Repo link: https://github.com/nxank4/loclean
I’d love to hear your feedback on the API design or use cases you might have for local data scrubbing. Thank you!

value: Show HN: Loclean – Local semantic data cleaning with LLMs and Pydantic


value: pdrojack

value: Show HN: Viahuman – Human In loop Notification system for LLMs

author: pdrojack


value: justvugg

value:
I built Polymcp, a framework that allows you to transform any Python function into an MCP (Model Context Protocol) tool ready to be used by AI agents. No rewriting, no complex integrations.
Examples
Simple function:
from polymcp.polymcp_toolkit import expose_tools_http
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b
app = expose_tools_http([add], title="Math Tools")
Run with:
uvicorn server_mcp:app --reload
Now add is exposed via MCP and can be called directly by AI agents.
API function:
import requests
from polymcp.polymcp_toolkit import expose_tools_http
def get_weather(city: str):
    """Return current weather data for a city"""
    response = requests.get(f"https://api.weatherapi.com/v1/current.json?q={city}")
    return response.json()
app = expose_tools_http([get_weather], title="Weather Tools")
AI agents can call get_weather("London") to get real-time weather data instantly.
Business workflow function:
import pandas as pd
from polymcp.polymcp_toolkit import expose_tools_http
def calculate_commissions(sales_data: list[dict]):
    """Calculate sales commissions from sales data"""
    df = pd.DataFrame(sales_data)
    df["commission"] = df["sales_amount"] * 0.05
    return df.to_dict(orient="records")
app = expose_tools_http([calculate_commissions], title="Business Tools")
AI agents can now generate commission reports automatically.
Why it matters for companies
 • Reuse existing code immediately: legacy scripts, internal libraries, APIs.
 • Automate complex workflows: AI can orchestrate multiple tools reliably.
 • Plug-and-play: multiple Python functions exposed on the same MCP server.
 • Reduce development time: no custom wrappers or middleware needed.
 • Built-in reliability: input/output validation and error handling included.
Polymcp makes Python functions immediately usable by AI agents, standardizing integration across enterprise software.
Repo: https://github.com/poly-mcp/Polymcp

value: Show HN: Polymcp – Turn Any Python Function into an MCP Tool for AI Agents

author: justvugg


value: lotusxblack

value:
Basically was getting annoyed jumping between 5 different sites during this winter storm season, so I built "StormWatch". It's a no-fuss, mobile-friendly webpage (dashboard) that shows all the stuff I was looking for, but in one simple UI.
Features:
- Real-time NWS alerts with safety tips
- Snow/ice/precip accumulation forecasts (+wind)
- Dynamic preparation checklists based on your alerts
- Supply calculator for your household size
- Regional weather news
It's free, no login required, works on any device. Just enter your ZIP.
https://jeisey.github.io/stormwatch/
Uses NWS and GDELT APIs and open source. Feel free to fork and modify however you'd like.
For builders:
- Used an API-testing agent to verify all endpoints, response patterns, types, and rate limits
- Used a scope & validation agent to keep the slices simple, focused, and tested
- VS-code Copilot (Sonnet 4 for dev agents + Opus 4.5 for scope and validation)

value: Show HN: StormWatch – Weather emergency dashboard with prep checklists

author: lotusxblack


value:
Hi HN,
I built a stateless, on-prem JSON-to-PDF generation service in Java.
Clients send JSON via REST and receive a generated PDF synchronously. No documents or payloads are persisted.
This is a commercial, proprietary on-prem product; the repository contains installation artifacts and documentation.
Feedback welcome

value: Show HN: Stateless On-Prem JSON-to-PDF via REST (Java)


value: ishaksebsib

value: An open-source, provider-agnostic Rust library for building AI-powered applications, inspired by the Vercel AI SDK.

value: Show HN: The AI-SDK for Rust Agents

author: ishaksebsib

title: Show HN: The AI-SDK for Rust Agents


value: ealpopa

value:
Over the weekend I ran a small experiment to see how quickly I could go from idea → working MVP using AI-assisted development tools.
The result is a simple web app that generates short, personalized bedtime stories and narrates them in my own voice. The codebase is intentionally rough in places, but the app works and has been usable in a real setting.
What surprised me most was how easy it was to iterate on a real, deployed system without getting stuck on early architectural decisions.
Stack: FastAPI, Supabase, Fly.io, Vercel
Tools: Cursor, Lovable, Claude, ChatGPT
Curious how others here are approaching AI-assisted development, and where you draw the line before hardening things for production.
Link: https://sleepli.app

value: Show HN: I built a bedtime story web app in a weekend using AI tools

author: ealpopa


value: takouzlo

value:
I built a local AI tool for professionals who handle sensitive documents (PDF/TXT).
- Runs with Ollama (llama3.2)
- No data leaves your machine — 100% offline
- Automatic language detection (FR/EN/DE)
- Open-source core (MIT License)
- Lightweight, fast, and privacy-first
Perfect for lawyers, accountants, auditors, and privacy-conscious teams in Europe.
GitHub: https://github.com/erabytse/docudeeper
Demo: ![Demo](https://raw.githubusercontent.com/erabytse/docudeeper/main/d...)
Feedback welcome!

value: Show HN: DocuDeeper – private document AI assistant,100% offline, GDPR-compliant

author: takouzlo


value: kirlts

value: Show HN: Witral: Self-hosted framework to ingest WhatsApp into Markdown/Obsidian

author: kirlts


value: neko-kai

value: Show HN: Kanata-switcher – per-application hotkeys for all Linux DEs

author: neko-kai


value: hissain

value: jSciPy is an open-source Java signal processing and scientific computing library inspired by SciPy.<p>It focuses on FFT, filters, PSD, STFT, DCT and Android compatibility, aiming to fill the gap for DSP-heavy workloads on JVM and Android.

value: Show HN: JSciPy – SciPy-inspired signal processing library for Java and Android

author: hissain


value: It's called ADHD Tabs. I'm a student with 3 months left to graduate, but no job yet. I must be on my toes, apply to jobs, and stay consistent, etc. However, with ADHD, it's just not easy to stay focused. I built this free Chrome extension to mitigate mine and my peers' impulsive tab opens. Hope it helps you, too!

value: Show HN: I built a no-sign up extension to help tab hoarders(Vanilla JavaScript)


value: georgedelair

value:
I've struggled with productivity apps my whole life—too many features, too many decisions before I can start working. So I built what I actually needed: four small browser tools that each do one thing.<p>- MonoDraft is distraction-free writing.
 - MonoTask is a task list with no tags/priorities/projects.
 - MonoTimer has a "gentle nag" mode and warnings at 5/2/1 minutes before time's up (context-switching is brutal for me).
 - MonoFlow is for dumping messy thoughts into a flowchart.<p>Built with vanilla JS, no frameworks. Everything saves to localStorage—nothing leaves your browser, no account needed.
Curious what other people find useful or what's missing.

value: Show HN: MonoSuite – Minimal productivity tools I built for my ADHD brain

author: georgedelair


value: saevarl

value:
Hi HN,
I’ve been working on a small project called Kontra and just released it.
Kontra is a data quality measurement engine. You define rules in YAML or Python, run them against Parquet, CSV, or database tables, and get back violation counts and sampled failing rows.
The main goal was to avoid doing more work than necessary. Instead of treating all rules the same, Kontra separates execution paths. Some checks can be answered from Parquet metadata alone, others are pushed down to SQL, and full in-memory scans only happen for rules that actually need them. The guarantees differ, and Kontra is explicit about that rather than hiding it.
Under the hood it uses DuckDB for SQL pushdown on files and Polars for in-memory execution. It also supports profiling datasets, drafting starter rules from observed data, and diffing validation runs over time. Rules can carry user-defined context, and runs can be annotated after execution without affecting validation behavior.
It works as both a CLI and a Python library.
Happy to answer questions or get feedback.

value: Show HN: Kontra - data quality validator that avoids unnecessary full scans

author: saevarl


value: tjohnell

value: Show HN: I made an app that blurs my screen when I slouch

author: tjohnell


value: owendarko

value:
Hey HN!
We have a Slack group with 30+ people and introduced this agent as a way for non-engs to push simple PRs and changes. This saves engs valuable time and context switching costs.
After a while, we expanded to this being a full-blown agent and you can see some interesting use cases in the blog post: https://blog.kilo.ai/p/announcing-kilo-for-slack
Any feedback is welcome!

value: Show HN: AI agent to create small PRs from Slack

author: owendarko


value: dcminter

value:
This GTK app for Linux [0] puts up a progress bar showing how much data is left in the "Dirty" and "Writeback" buffers. For good measure it also shows the progress on most simple file operations such as cp or mv.
The main purpose is to scratch my own itch when copying large files onto a USB drive. I want to be able to see the progress of sync (or "eject") operations whose feedback usually amounts to "wait" or "finished" !
At the CLI, of course, you can instead run progress [1] or just manually grep for "Writeback" in /proc/meminfo [2] but personally I like having something graphical!
[0] https://github.com/dcminter/meminfo-rs
[1] https://github.com/Xfennec/progress
[2] https://man7.org/linux/man-pages/man5/proc_meminfo.5.html

value: Show HN: A GTK app for Linux to show file buffer progress

author: dcminter


value: skinnyasianboi

value: Show HN: Modbhold – Vanilla JavaScript open source browser game

author: skinnyasianboi


value: melnce

value:
Germany is requiring all B2B invoices to be in structured e-invoice format (XRechnung/ZUGFeRD) starting January 2025.
Problem: Millions of freelancers and small businesses still create invoices in Word, Excel or PDF. Switching to new accounting software just for this feels like overkill.
I built e-rechnung.tools – upload your existing invoice, it extracts the data and generates compliant XML. No account needed for basic use.
Tech: Python backend, PDF parsing with pdfplumber, built the XRechnung XML generator from scratch based on the official specs.
Would love feedback on:
- UX (is the flow clear?)
- Pricing (currently freemium with paid tiers)
- Any edge cases I'm missing?

value: Show HN: Convert Word/Excel/PDF Invoices to XRechnung (German 2025 Mandate)

author: melnce


value: shannoncode

value:
https://github.com/genecyber/Reflexive/blob/main/demo1_clipp...
I’ve wanted a specific thing for years: AI embedded in the runtime.
Catch an exception → run a prompt. API failure → scan docs for schema changes → patch the response.
I discovered the Claude Agent SDK is effectively “Claude Code as a library” (same agent loop + tools), so I asked:
what if the agent doesn’t just edit code — what if it lives inside the running process?
Reflexive runs your app and opens a local web UI where the agent can:
- watch stdout/stderr and trigger investigations from log patterns
- read/edit project files (explicit flags)
- start/stop/restart the process
- attach to the Node inspector and set real V8 breakpoints
- inspect locals/scopes while paused, optionally run prompt-attached breakpoint analysis, then resume
Two moments convinced me this is a different primitive:
1) I started from an empty file. The app exited(1). The agent asked if I wanted it fixed.
   Minutes later it had converted it into a working webserver, then kept working after I stopped typing (it curl-tested its own endpoints and narrated why it kept the process alive).
2) I set a breakpoint before an API response, mutated one value to “Customer.Hacked”, resumed, and the agent treated it like an incident: it isolated the relevant code path, disabled the risky behavior, restarted the process, and wrote a postmortem.
This is intentionally a dev tool first: the power is behind explicit flags.
If you try it and it breaks, I’d love the failure reports — the whole point is runtime-level feedback loops.

value: Show HN: I embedded Claude inside a running Node app

author: shannoncode


value: Show HN: A tiny scalar that detects regression drift before CI tests fail


value: Feedback is appreciated

value: Show HN: Unicode Explorer – Explore, Search, and Export Unicode Characters

story_text: Feedback is appreciated


value: MoKetchups

value: Show HN: AI architectures tested against their own structural limits

author: MoKetchups


value:
I've been building a bitly alternative in public and built a free side tool to upload screenshots to S3. I always thought screenshot apps charged way too much for this so I was pretty happy to get around to build it.
It automatically generates short links and uploads to any S3-compatible storage you own.
Here is the link:
https://gofwd.to/screenfwd
Try it out, all feedback is welcome :)

value: Show HN: I built a Mac OS App to upload your screenshots to S3


value: david-minaya

value:
I want to share Ask CLI, a tool I developed to get help with commands and coding directly from the terminal. It is a simple app designed to do one thing well: provide instant command assistance. This isn't a complex coding agent like Claude Code; it is built specifically to get short, fast answers without context switching.
As a developer, I’ve always struggled to remember every command and its specific options. Whenever I need to use tools like Docker, Git, or psql, I find myself leaving the terminal to check documentation or scrolling through verbose --help text just to recall a specific flag. I usually know what I want to do, but I forget the exact syntax. I didn't want to waste time switching to Google or ChatGPT just to find a one-line command.
I developed Ask CLI to solve this. It has been a game-changer for my workflow. Now, when I forget a command, I simply ask my terminal. It gives me a fast, precise answer—exactly what I need—without breaking my flow.
It is incredibly easy to use: just select an AI model, set your API key, and start chatting naturally with your terminal.
Examples:
$ ask how to run a docker container with env variables
$ ask how to setup my local git account
You can also use the "what" and "how" aliases for a more natural feel:
$ what is chmod
$ how to print all the env variables
You can use Ask CLI with popular hosted models (Gemini, Claude, ChatGPT) or with local models and external providers that support OpenAI-compatible APIs (Ollama, llama.cpp, LM Studio, etc.).
Ask CLI is free and open-source. Check it out here:
https://github.com/david-minaya/ask

value: Show HN: Ask CLI – A simple tool to get help with commands from the terminal

author: david-minaya


value:
Seven modules teaching C the way safety-critical systems are actually built: MATH → STRUCT → CODE → TEST.
Each module answers one question: Does it exist? (Pulse), Is it normal? (Baseline), Is it regular? (Timing), Is it trending? (Drift), Which sensor to trust? (Consensus), How to handle overflow? (Pressure), What do we do about it? (Mode).
Every module is closed (no dependencies), total (handles all inputs), deterministic, and O(1). 83 tests passing.
Built this after 30 years in UNIX systems. Wanted something that teaches the rigour behind certified systems without requiring a decade of on-the-job learning first.
MIT licensed. Feedback welcome.

value: Show HN: C From Scratch – Learn safety-critical C with prove-first methodology


value: czheo

value: Show HN: Skget, another CLI to add skills to your coding agents

author: czheo


value: jellyotsiro

value:
I built an AI agent that searches the entire Cursor community forum (http://forum.cursor.com/) and answers questions grounded in real forum discussions.
The problem: Cursor's forum has tons of valuable content - feature discussions, troubleshooting threads, tips from power users - but it's hard to search. Traditional forum search is keyword-based and misses a lot of context.
The solution: I indexed the entire forum using Nia (a knowledge indexing service) and connected it to an AI agent with multiple search tools:
- Semantic search - finds relevant posts even when wording differs
- Pattern search (grep) - exact matching for error messages, usernames, specific terms
- Full thread reading - AI can dive deep into specific discussions
- Web search fallback - for questions the forum doesn't cover
GitHub: https://github.com/nozomio-labs/nia-cursor-forum-search
Would love feedback on the approach!

value: Show HN: AI agent that searches the Cursor forum

author: jellyotsiro


value: qq-niklas

value:
About a month ago, I shared the Day 1 prototype of this project (https://news.ycombinator.com/item?id=46448670). It has since evolved into a somewhat more polished "Slot-Machine Deckbuilder."
I also recently moved the project from qq-pwn.com to alt-qq.com. I did this mid-development specifically to see if I could migrate a live player base and session states without losing people.
The Design Challenge:
The core of the game is a "One-Armed Bandit" dungeon crawler. The challenge is balancing the "house always wins" nature of slots with the player agency required for a good roguelike.
What I’d love your feedback on:
The First 30 Seconds: Is it immediately obvious how to play? I’ve tried to keep the onboarding "invisible," but I worry the manipulation mechanics might be buried.
Skill vs. Luck: Does the game feel like a mindless gamble, or do you feel like you have agency over the outcome?
The "Cursed Seed" UX: I’ve added a way to share specific runs via a URL. Does the transition from "clicking a friend's link" to "playing the game" feel seamless?
Mobile/PWA Performance: It’s built to be a PWA. Does it feel like a "web page" or does it feel like a native app on your device?
I'm especially interested when and where exactly did you feel like quitting?
Technology:
The project is built with React and Vite, hosted on a Cloudflare edge stack. The code is 100% augmented by AI, which allowed me to focus more on the architecture of the project and the design of the mechanics rather than implementation syntax.
Reel Rogue: The Bandit's Tale is playable here: https://alt-qq.com

value: Show HN: Reel Rogue – A browser roguelike (idler) about manipulating the odds

author: qq-niklas


value: smashah

value:
Hi HN,
For anyone using pnpm-workspace.yaml to manage your deps, you can now use the following command to automatically find duplicate dependencies that can be hoisted into `pnpm-workspace.yaml` file with
npx workspace-updater dupes
and in order to commit just add the -y flag, and you can resolve the conflicts to use the latest version using --resolve-latest.
Any feedback, ideas appreciated!
https://github.com/smashah/workspace-updater?tab=readme-ov-f...

value: Show HN: Workspace-updater can now hoist common deps

author: smashah


value: uprooted

value: Show HN: IntegrateStack, a Resource Hub for SaaS Integration Specs and Issues

author: uprooted


value: blacktis

value: L3 Engine is a market surveillance system written in Rust. It doesn't just look at the price; L3 reconstructs the individual order flow (Level 3) to reveal market intent: it detects spoofing, layering, and phantom liquidity in microseconds, before the price moves.

value: Show HN: L3Binance – Market surveillance engine in Rust with integrated ML

author: blacktis


value: mosbyllc

value:
Programming has always felt like a high wall to me. In my day job, I am the "junior" engineer—the one who gets stuck on syntax while others ship features. I often doubted if I was cut out for this.
But recently, I experimented with "vibe coding"—where I focus on the logic and flow, and let AI handle the implementation details. The result is AIMovieQuotes (https://www.aimoviequotes.com).
It is a simple but useful engine: you search for iconic lines from movies, TV, and songs by mood, theme, or keyword.
The process was a revelation. In the past, I would have abandoned this project when the CSS broke or the database queries got complex. This time, I acted as the architect. I described the outcome, and the AI paved the road.
For the first time, I felt the pure joy of creation rather than the frustration of debugging.
I am sharing this not just to show off the tool, but to share a realization: The gap between "having an idea" and "shipping a product" is vanishing. Even for a "weak" coder like me, building a complete product is now possible.
I hope you find the quotes you need, but more importantly, I hope this encourages other juniors to stop worrying about syntax and start shipping.

value: Show HN: I built a quote search engine via "vibe coding" as a junior dev

author: mosbyllc


value:
Hi HN,
I’ve been experimenting with LLM agents for a while and often felt that
for simple workflows (chat, tool calls, small loops), existing
frameworks add a lot of abstraction and boilerplate.
So I built a small Python library called PicoFlow. The goal is simple:
express agent workflows using normal async Python, not
framework-specific graphs or chains.
Minimal chat agent
Each step is just an async function, and workflows are composed with >>:

  from picoflow import flow, llm, create_agent

  LLM_URL =
  “llm+openai://api.openai.com/v1/chat/completions?model=gpt-4.1-mini&api_key_env=OPENAI_API_KEY”

  @flow
  async def input_step(ctx):
      return ctx.with_input(input(“You:”))

  agent = create_agent(
      input_step >>
      llm(“Answer the user: {input}”, llm_adapter=LLM_URL)
  )

  agent.run()

No chains, no graphs, no separate prompt/template objects. You can debug
by putting breakpoints directly in the async steps.
Control flow is just Python
Loops and branching are written with normal Python logic, not DSL nodes:

  def repeat(step):
      async def run(ctx):
          while not ctx.done:
              ctx = await step.acall(ctx)
              return ctx
          return Flow(run)

The framework only schedules steps; it doesn’t try to own your control
flow.
Switching model providers = change the URL
Another design choice: model backends are configured via a single LLM
URL.
OpenAI:

  LLM_URL =
  “llm+openai://api.openai.com/v1/chat/completions?model=gpt-4.1-mini&api_key_env=OPENAI_API_KEY”

Switch to another OpenAI-compatible provider (for example SiliconFlow or
local gateways):

  LLM_URL =
  “llm+openai://api.siliconflow.cn/v1/chat/completions?model=Qwen/Qwen2.5-7B-Instruct&api_key_env=SILICONFLOW_API_KEY”

The workflow code doesn’t change at all. Only runtime configuration
does. This makes A/B testing models and switching providers much cheaper
in practice.
When this is useful (and when it’s not)
PicoFlow is probably useful if you:
-   want to prototype agents quickly
-   prefer explicit control flow
-   don’t want to learn a large framework abstraction
It’s probably not ideal if you:
-   rely heavily on prebuilt components and integrations
-   want a batteries-included orchestration platform
Repo:
https://github.com/the-picoflow/picoflow
This is still early and opinionated. I’d really appreciate feedback on
whether this style of “workflow as Python” is useful to others, or if
people are solving this in better ways already.
Thanks!

value: Show HN: PicoFlow – a minimal Python workflow for LLM agents


value: Hacakthon

value:
I’m a computer engineering student at SPPU. While working on a project with React 19, I realized that the standard libraries we use for SEO (like React Helmet) are still doing things the "old" way.
The Problem: Older libraries use a trick called "side effects" to change your page title and meta tags after the page has already loaded. This can cause the title to flicker or make the site feel a bit slower because the browser has to do extra work.
The Solution: React 19 added a built-in feature that lets it move tags to the top of the page (the <head>) automatically. I built react-meta-seo to make this new feature easy to use for everyone.
Why it’s simpler for developers:
No "Provider" needed: You don't have to wrap your whole app in a special component. It just works wherever you drop it.
Tiny size: It’s under 4KB. For comparison, legacy options are usually 15KB or more.
No more broken Google data: It checks your Google Search data (JSON-LD) automatically to make sure it’s formatted correctly.
Built-in Preview: I added a tool so you can see what your site will look like on Twitter or Facebook while you're still coding.
Simple Sitemap Tool: It includes a command-line tool to make your sitemap.xml for you.
I wanted to build something that used the new React 19 features to make SEO faster and easier to set up. I’d love to get some feedback on the code!
GitHub: https://github.com/ATHARVA262005/react-meta

value: Show HN: React-meta-SEO – Rebuilding SEO for React 19 (3KB, no providers)

author: Hacakthon