value: afrazullal

value:
Hi HN,
I’m Muhammed Mufinuddin Afraz, a solo technical founder based in Ullal, Karnataka, India.
For the past 12 months, I’ve been building Vect AI — an Autonomous Marketing Operating System designed to replace the fragmented “modern marketing stack.”
The Thesis: The Stack Is Broken
Modern marketing requires juggling 10–15 disconnected tools: one for writing, one for images, one for SEO, one for CRM, plus automation glue in between. For solo founders and lean teams, this creates siloed data, lost context, and endless prompt-copying. You spend more time managing tools than building growth.
I didn’t want a better chatbot.
I wanted a command center.
What Is Vect AI?
Vect is a state-aware marketing OS.
Unlike ChatGPT-style tools that reset context every session, Vect maintains a persistent business kernel. Onboarding happens once:
Brand voice (e.g. professional, technical, witty)
Audience avatar
Core product truths
Every tool inside Vect inherits this state automatically. I never have to re-prompt “act like a B2B SaaS marketer” again — the system already knows.
Architecture: Three Layers of Autonomy
1. Sensor Layer (Grounding & Research)
Most AI content is generic because it hallucinates or relies on stale data. Vect’s Market Signal Analyzer addresses this by:
Performing real-time web retrieval via Google Search APIs
Analyzing top-ranking content to detect information gaps
Scoring subtopics by velocity (0–10) to surface early “blue ocean” opportunities
2. Strategist Layer (Planning & Logic)
This is the hardest problem: getting an LLM to plan without hallucinating.
Vect’s Campaign Builder takes a goal (e.g. “Launch a Black Friday offer”) and generates a structured, multi-phase plan:
Tease (anticipation)
Launch (conversion)
Close (urgency)
It produces a campaign canvas showing all required assets (emails, posts, blogs) and enforces consistency across the entire funnel.
3. Creative Layer (Execution)
Vect integrates specialized agents for SEO, email, and social copy using proven frameworks (PAS, AIDA).
It also integrates Google’s Veo model for physics-aware text-to-video generation, enabling high-quality commercial assets without context switching.
Why Build This From India?
Building from Ullal means no VC safety net and no large team — just code and time. That constraint forced radical efficiency.
I didn’t hire a strategist; I built the planner.
I didn’t hire a researcher; I built the analyzer.
I didn’t hire a video editor; I integrated one.
Vect is designed to make a solo founder operate like a full marketing team.
Availability
Vect is a web-based app using a credit system, since deep research and video generation incur real compute costs.
I’d appreciate feedback on:
The state-aware approach to brand consistency
Whether the Campaign Builder feels too rigid or appropriately opinionated
What other painful parts of your marketing workflow should be automated next
Link: https://vect.pro
Location: Ullal, Karnataka, India

value: Show HN: I Built an Autonomous Marketing OS from a Small Town in India (Vect AI)

author: afrazullal


value: codebyprakash

value:
Hi HN,
I built MetroYatra to solve everyday metro travel problems in India — confusing routes, unclear interchanges, and unpredictable travel time.
MetroYatra helps people plan metro journeys across all metro cities in India with clear routes, distances, interchanges, fares, and time estimates.
I’d love feedback from the community, especially on usability, performance, and data accuracy.

value: Show HN: MetroYatra – Metro Route Finder For Indian Cities

author: codebyprakash


value: SamTinnerholm

value:
If you've ever tried to integrate crypto market data into an app, you know the pricing for commercial APIs gets crazy fast. I couldn't justify the cost for my projects, so I built my own solution.
I learned to index and query the blockchain directly, cutting out the middleman fees.
The result is qoery.com.

value: Show HN: 85% Cheaper Crypto Data

author: SamTinnerholm

title: Show HN: 85% Cheaper Crypto Data


value: knlgwr

value: Show HN: Roam Cinema – Discover worldwide cinema via interactive world map

author: knlgwr


value: pierremouchan

value:
what is MethodsAgent?
It gives you domain-specific AI agents that turn proven playbooks (like copy frameworks, AARRR metrics, or Jobs-to-be-Done) into actual execution-ready assets. Instead of getting generic advice, you get verified output—landing page copy, cold outreach scripts, and funnel strategies—based on 50+ curated marketing frameworks. Think of it as a "Cursor for Marketing".
Why I built it?
I’m a builder who has spent the last 5 years obsessively collecting over 1,000 frameworks. But even with that library, I found myself spending 40+ hours trying to learn what experts already knew, or relying on generic ChatGPT answers that lacked depth. I built this because I wanted instant access to expert-level marketing execution without hiring a $5k/mo consultant or spending months learning a new domain.
The pain it solves?
Founders and indie hackers often build great products but get stuck at marketing... We know how to build, but we struggle to sell because we lack the domain expertise. MethodsAgent bridges that gap by giving you the "methods" of experts, instantly applied to your specific product.
I’m not looking for upvotes, but honest feedback.
Does the output feel more actionable than standard LLMs?
Which marketing frameworks would you actually use right now?
Thanks!

value: Show HN: MethodsAgent – Solves "I can build but can't sell" for founders

author: pierremouchan


value: appetizersnack

value: Turn every website into your personal notepad. Pin sticky notes in your favorite colors, keep ideas organized, and revisit them anytime. Perfect for research, reminders, or simply keeping track of thoughts while you browse.

value: Show HN: Add sticky notes to any page on the web

author: appetizersnack


value:
Hey HN,
v0 of a small experiment: a script that counts your page views (done so many times) but exposes them on a public URL so traffic becomes third‑party and linkable instead of “here’s a screenshot of my analytics”.
Adding trust & shareable
I’m curious if this is actually useful for you:
For blogs/directories/communities that sell “exposure”, would public verified views help you prove you send traffic?
For projects, would you use a simple public stats page in launch posts, open‑startup pages, or as a trust badge?
What must be on that page (just views, growth chart, referrers?), and what would stop you from adding it?
Would love blunt feedback on whether this solves a real problem and what would make you install it on your own site.

value: Show HN: I made a public traffic counter so websites can share verified views


value: charlielidbury

value: If agent's tools are exposed as functions/objects in a Python REPL (as opposed to JSON schemas) they perform better, I linked the explainer article we wrote, but if you want to jump straight in check out the docs! https://docs.symbolica.ai/

value: Show HN: Calling tools w/ Python improves LLM perf. vs MCP (77.1% on BrowseComp)

author: charlielidbury


value: aroussi

value:
I'd love to hear what you think. You can download the first 3 chapters (no opt-in):
https://productionaibook.com/hn

value: Show HN: I Wrote a Book – Production-Grade Agentic AI

author: aroussi


value: Show HN: AI agent demo that runs purely on WebAssembly and open-source models


value: rohithreddyj

value: Show HN: Resumeup.ai – ATS optimised resumes that lands you interviews

author: rohithreddyj


value: appdevfun

value:
Hey HN! I built Zone, an iOS app blocker with usage attempt tracking.
The core idea: most app blockers just block apps, but I wanted to see how often I was actually trying to open them. Turns out I was attempting to open Instagram 40+ times a day without even realizing it. That number was more effective at changing behavior than just blocking alone.
Technical bits:
Built using Apple's Family Controls API (which was... interesting to work with)
Tracks block attempts without storing any actual usage data
Simple scheduling system for focus sessions
No subscription model - one-time unlock
The Family Controls API is pretty powerful but has some quirks - you need to use Screen Time authorization, and the blocking is system-level so it's actually reliable (unlike overlays or redirects).
Started this as a personal tool after trying several blockers and finding none that surfaced this "attempt count" data. Figured others might find it useful too.
Happy to answer questions about implementation or the API if anyone's curious!

value: Show HN: Zone – App blocker that tracks how often you try to open blocked apps

author: appdevfun


value: cutandjoin

value:
An MP3 editor and player focused on working with multiple files at once.
Similar to mp3DirectCut, MP3Gain, and MP3packer.
Recent updates add language file import support and expanded keyboard shortcut customization.

value: Show HN: MP3 File Editor / Player for Windows

author: cutandjoin


value: hamachang

value:
Hi HN! I’m Hamachang, a Rubyist from Japan.
I’d like to share a project I’ve been working on for quite some time: Ruby-TI, a static type checker / type analyzer for mruby — now at major version 1.0!
Ruby-TI is written in Go and performs parse → type inference → type checking on mruby code. If you’re embedding mruby or writing mruby scripts, it can help catch type issues before runtime — something that’s often missing in dynamic languages like Ruby.
What Ruby-TI does
Parses mruby source code
Infers types and checks for type errors
Helps find type mismatches early
Includes editor integrations (e.g., LSP support) for better development experience
Why this matters
mruby is a lightweight, embeddable implementation of Ruby, great for scripting in applications or constrained environments. Catching type errors statically can save debugging time and increase confidence in your code — even without annotations.
Try it out
https://github.com/engneer-hamachan/ruby-ti
I’d love to hear feedback — issues, feature requests, or anything you find interesting!

value: Show HN: Ruby-TI – Static Type Checker for Mruby (Version 1.0)

author: hamachang


value: haneboxx

value: Hi! I just made an obsdian alternative in terminal after searching for an Obsidian like TUI and got nothing. So I built one myself.

value: Show HN: Open-source Markdown research tool written in Rust – Ekphos

author: haneboxx


value: Show HN: Building a full-stack Cloudflare starter kit (Hono and D1 and Stripe)


value: Show HN: Reasoning models don't guarantee better security


value: dboon

value:
I noticed that Claude Code added a /stats command, and that the stats are cached in $HOME/.claude, so I made a fun program with Bun + WASM that pulls the stats (nonsensitive, nonidentifiable), posts them to a database, and lets you see where your usage lies.
The WASM part is a very fun raymarched SDF renderer that renders a special wintertime Claude in your terminal. If you're just interested in this part, it renders in the browser, too. I've named him Santa Claude.
The code is here[^1] if anyone's interested in the rendering code or wants to make sure I'm not exfiltrating their credit card.
[^1]: https://github.com/tspader/claude-wrapped/

value: Show HN: Claude Wrapped, compare your CC usage globally and a 3D terminal render

author: dboon


value: gztomas

value:
We’re shipping an execution model that sits between LLM code generation and autonomous agents.
The LLM generates only the glue logic between two deterministic interfaces:
- a UI schema the frontend knows how to render
- a constrained runtime interface exposed by the backend, from specific functions like list_comments to broader primitives like a restricted http_call
Both interfaces are fixed, typed, and inspectable. The LLM can’t invent UI components or backend capabilities. It only composes what already exists.
This is adjacent to A2UI, but the cut is different. A2UI renders agent actions into UI. Here, UI and runtime are first-class, and the LLM generates the composition logic without an open-ended action loop.
You can also think of it as MVC where the View and Model are fixed, and the Controller is generated on demand.
Write-up and short demo video:
https://cased.com/blog/2025-12-11-how-we-build-generative-ui...
Interested in feedback on failure modes, constraints, and related prior art.

value: Show HN: LLMs generating glue logic between UI schemas and constrained runtimes

author: gztomas


value: lexokoh

value: I built this after repeatedly running into the same problem as a mobile developer using AI APIs. Best practice says you shouldn’t ship API keys in a mobile app, but the alternative is always the same: spin up a backend server that does nothing except proxy requests to OpenAI. That server adds cost, complexity, scaling work, and maintenance to forward a request and hide a key. I kept rebuilding this “useless” backend over and over, and eventually realized: if you’re forced to have a backend anyway, it should actually do something valuable.<p>That insight led to the development of a simple, secure AI proxy that handles key management, rate limits, usage controls, promotions, and upgrades. So mobile developers can keep their frontends clean without managing custom backend infrastructure.

value: Show HN: Why every mobile AI app accidentally becomes a backend company

author: lexokoh


value: Show HN: LyneCode Beats AntiGravity and Codex (and It's Open Source)


value: TypeDeck

value:
Hey HN. I built TypeDeck (https://typedeck.io) because I work in Markdown and hated copy-pasting to make presentations in Google Slides, Powerpoint, etc.
The format is intentionally simple: minimal GUI and if you're keyboard-first, standard markdown and HTML comments do it all. Github sync, export to PDF/PPTX.
Technical details for the curious:
- React 19 + Vite, Firebase backend
- CodeMirror 6 for the editor
- pptxgenjs for PowerPoint export (this was painful - PPTX is a wild format)
- Mermaid rendering for diagrams
- Design token system with 8px baseline grid, WCAG AA color contrast
- I designed it around how LLMs output text. Ask ChatGPT/Claude for slides, paste the markdown, done. No reformatting step.
What's missing:
- No speaker notes (most requested feature, haven't built it)
- No animations or transitions
- Limited to 9 layouts - if you need pixel-perfect custom positioning, this isn't the tool
- No collaboration yet
I'd appreciate feedback. First, are these "write markdown, get slides" apps actually useful, or do people want more control than this allows? What layouts am I missing? What would make you use this over just opening Google Slides?
Happy to answer questions about the implementation. Thanks for taking a look!

value: Show HN: TypeDeck – Markdown, Mermaid, etc. to presentation slides

author: TypeDeck


value: tchantchov

value:
I've built PremiumFlow to solve a problem I kept running into as an options trader: managing the true cost basis of my positions when selling puts and covered calls.
The Problem: When you sell puts or covered calls, the premium you collect reduces your effective cost basis, but manually tracking this across multiple positions became a mess. Most trading platforms don't account for this properly, making it hard to know your true entry price and whether a trade is actually profitable.
The Solution: PremiumFlow lets you integrate option premiums directly into your LEAPS and stock cost basis.
Now when you:

  - Sell puts against cash reserves, the premium lowers your true entry price when assigned

  - Sell covered calls against your stock holdings, the premium improves your effective cost basis

This means you can finally calculate realistic break-even points and make better decisions on whether to roll, close, or hold positions.
How it works: Track your stock LEAPs, input your option trades, and see your adjusted cost basis automatically calculated.
Makes it way easier to manage undefined-risk strategies like put-selling and covered calls at scale.
Check it out: https://premiumflow.base44.app
Would love feedback from the trading and options community here.
Thank you!

value: Show HN: PremiumFlow – Managing Option Selling

author: tchantchov


value: mikeouroumis

value: Show HN: CLI that turns GitHub issues into PRs with Claude Code

author: mikeouroumis


value: chialunhera

value:
Hi HN, we've built an API that turns text prompts into professional motion graphics animations.
Generative video models directly output pixels, producing a flat video file with no underlying structure and no way to edit individual elements. Hera, by contrast, uses LLMs to generate code that is then rendered into an animation. This approach enables far greater precision and control over every element, while ensuring clean edges, precise text, and transparent background support (alpha channels)
API Use Cases:
- AI Video Agents: Generating B-roll, lower thirds, and overlays to complement talking head avatars (e.g., HeyGen/Synthesia pipelines).
- Faceless Channels: Automating visual content for Reddit stories, trivia, or history channels on YouTube/TikTok.
- Data Storytelling: Programmatically turning datasets into animated charts, graphs, and map zooms.
- Marketing Automation: Scaling branded social assets, ads, and intros/outros without manual editing.
- EdTech: Automatically converting educational text or summaries into engaging visual explanations.
Input: Text prompt (e.g., "Kinetic typography intro saying 'Breaking News'") Output: Rendered video (MP4/MOV/GIF/WebM) API docs: https://docs.hera.video
We're looking for feedback on the API structure and other potential automation workflows you might need.
Try our API for free ($5 credits) by doing these steps:
1. Go to http://hera.video/join/HACKERNEWS
2. Go to https://app.hera.video/settings/developers
3. Click "Create key" to generate a new API key
Thanks!

value: Show HN: Hera API – Text-to-Motion-Graphics Engine

author: chialunhera


value: subhadipmitra

value: Show HN: Spark-LLM-eval – Distributed LLM evaluation for Spark

author: subhadipmitra


value: jreola

value: Show HN: Speechbolt – AI receptionist to screen calls and surface TCPA signals

author: jreola


value: rainco

value:
Hi HN, author here.
I am a 48-year-old ex-computer scientist returning to coding after a 20-year hiatus. I built Evochora because I wanted to tackle a specific problem in Artificial Life: Evolutionary Stagnation, analogous to the "boring billion" in Earth's evolution.
Scientific ALife simulators often hit a complexity ceiling. My hypothesis is that overcoming this requires a modular platform for flexible experimentation with "digital physics" rather than hard-coded rules.
Evochora was designed to be this platform. Its core philosophy is to test these hypotheses without modifying the core engine, which is enabled by plugin systems throughout:

    *VM & Compiler*: Turing-complete VM with configurable registers/stacks. Multi-pass compiler for EvoASM (Lexer → Parser → Semantic Analysis → IR → Layout → Linker → Emitter). Both extensible via plugins—add instructions, constraints, optimization passes, or syntax extension without touching core code.

    *Embodied Simulation*: Organisms are embodied agents in an n-dimensional grid, interacting via physical Instruction Pointers and Data Pointers not scripts in a sandbox.

    *Distributed Pipeline*: Hot path (flattened int32 arrays for cache locality) + cold path (queues, scalable persistence/indexing). Debugging and Analytics frontend with plugin-based custom metrics.

Current Status & Next Steps:
A primordial replicator (written in EvoASM) is functional. I was able to overcome the expected initial genome degeneration (organisms corrupting neighbors) by enforcing configurable thermodynamic policies. Now populations are much more stable, which allows to shift the focus from survival to evolvability. Next things I want to address:
* Mutation Model: I want to build a plugin system that allows for experimentation with different mutation models (from simple bitflip to complex genome rearrangements)
* Fuzzy Addressing: I intend to investigate fuzzy jump targets (inspired by SignalGP) to decouple instruction targets from physical memory addresses, potentially improving genomic resilience.
* Signaling & Concurrency: I aim to explore how organisms can utilize the FORK opcode to spawn additional execution contexts internally and use internal signaling, which could be a kind of digital eukaryogenesis.
The Ask:
The project is fully Open Source (MIT License). I'm looking for contributors and critical feedback on the architecture. With the thermodynamic baseline now established, I specifically invite researchers and systems engineers to collaborate on the next frontiers: designing the mutation models and signaling protocols required to investigate emergent complexity
Tech Stack: Java/Gradle. Full disclosure: AI was my primary coding partner (after 20 years away from coding), but all architectural and design decisions were mine. Happy to discuss the architecture here; AI workflow details on Discord if interested.
Repo: https://github.com/evochora/evochora
Demo: http://evochora.org (live simulation + video)
Discord: https://discord.gg/SXSDvfcm
Whitepaper (draft!): https://github.com/evochora/evochora/blob/main/docs/SCIENTIF...
Happy to discuss any tech details or the scientific approach!

value: Show HN: Evochora – A Laboratory for Embodied Artificial Life Research

author: rainco


value: giovapanasiti

value: Show HN: Turn your tracks into spinning vinyl videos in seconds

author: giovapanasiti


value: Show HN: Steer (v0.2) – Active reliability layer for AI agents (Python)


value: ThailandJohn

value:
I’m a former Systems Architect (Cisco/VMware) turned builder in Thailand. TheAuditor v2.0 is a complete architectural rewrite (800+ commits) of the prototype I posted three months ago.
The "A-ha" moment for me didn't come from a success; it came from a massive failure. I was trying to use AI to refactor a complex schema change (a foundation change from "Products" to "ProductsVariants"), and due to the scope of it, it failed spectacularly. I realized two things:
* Context Collapse: The AI couldn't keep enough files in its context window to understand the full scope of the refactor, so it started hallucinating, "fixing" superficial issues. If I kept pressing it, it would literally panic and make up problems "so it could fix them," which only resulted in the situation going into a death spiral. That’s the villain origin story of this tool. :D
* Stale Knowledge: It kept trying to implement Node 16 patterns in a Node 22 project, or defaulting to obsolete libraries (like glob v7 instead of v11) because its training data was stale.
I realized that AI agents are phenomenal at outputting working code, but they have zero understanding of it. They optimize for "making it run at any cost"—often by introducing security holes or technical debt just to bypass an error. This is a funny paradox because when "cornered/forced" to use cutting-edge versions, syntax, and best practices, it has zero issue executing or coding it. However, it’s so hilariously unaware of its surroundings that it will do anything else unless explicitly babysat.
I built v2 to be the "Sanity Check" that solves a lot of these issues, and it aims to continue solving more of the same and similar issues I face. Instead of letting the AI guess, TheAuditor indexes the entire codebase into a local SQLite Graph Database. This gives the AI a queryable map of reality, allowing it to verify dependencies and imports without needing to load "all" files into context.
A/B Demo: https://www.youtube.com/watch?v=512uqMaZlTg
As seen in the demo video, instead of trying to read 10+ full files and/or grepping to make up for the hallucinations, it can now run "aud explain" and get 500 lines of deterministic "facts only" information. It gets just what it needs to see versus reading 10+ files, trying to keep them in context, finding what it was looking for, and trying to remember why it was looking to begin with.
I also learned that regex/string/heuristics don't scale at all and are painfully slow (hours vs minutes). I tried the regex-based rules/parsers approach, but they kept failing silently on complex files and suffered constant limitations (the worst offender was having to read all files per set of rules). I scrapped that approach and built a "Triple-Entry Fidelity" system.
Now, the tool acts like a ledger: the parser emits a manifest, the DB emits a receipt. If they don't match, the system crashes intentionally.
It’s no longer just a scanner; it’s a guardrail. In my daily workflow, I don't let the AI write a line of code until the AI (my choice just happens to be CC/Codex) has run a pre-investigation for whatever problem statement I'm facing at the moment. This ensures it's anchored in facts and not inference assumptions or, worse, hallucinations.
With that said, my tool isn't perfect. To support it all, I had to build a pseudo-compiler for Python/JS/TS, and that means preparing extractors for every framework, every syntax—everything, really. Sometimes I don't get it right, and sometimes I just won't have had enough time to build it out to support everything.
So, my recommendation is to integrate the tool WITH your AI agent of choice rather than seeing it as a tool for you, the human. I like to use the tool as a "confirm or deny," where the AI runs the tool, verifies in source code, and presents a pre-implementation audit. Based on that audit, I will create an "aud planning."
Some of the major milestones in v2.0
* Hybrid Taint: I extended the Oracle Labs IFDS research to track data flow across microservice boundaries (e.g., React fetch → Express middleware → Controller).
* Triple-Entry Fidelity: This works across every layer (Indexer -> Extractor -> Parser -> Storage). Every step has fidelity checks working in unison. If there is silent data loss anywhere in the pipeline, the tool crashes intentionally.
* Graph DB: Moved from file-based parsing to a SQLite Graph Database to handle complex relationships that regex missed.
* Scope: Added support for Rust, Go, Bash, AWS CDK, and Terraform (v1 was Python/JS only).
* Agent Capabilities: Added Planning and Refactor engines, allowing AI agents to not just scan code but safely plan and execute architectural changes

value: Show HN: TheAuditor v2.0 – A “Flight Computer” for AI Coding Agents

author: ThailandJohn


value:
Hello,
I built weekinpapers.com to address what I saw as a "discoverability" problem for arXiv papers in Computer Science.
As the course of the calendar week progresses, the homepage will update to show newly-published papers as they come in. The process will start again the following week.
Each entry features a AI-generated "ELI5" summary, in an attempt to demystify, and make explicit, any keywords or assumed knowledge. I see this as a valid use-case for LLMs. The hope is, that cutting edge research becomes accessible to a broader audience.
Matt

value: Show HN: WeekInPapers – A Modern ArXiv Reader


value: kreeben

value: Show HN: Vector space as a file (three files, really)

author: kreeben


value: I built ServerCompass after spending too many evenings SSHing into VPS to deploy side projects. The latest feature lets you deploy Docker apps through a visual wizard instead of remembering all the docker-compose commands

value: Show HN: GUI for deploying Docker apps to VPS


value: devjelly

value:
I created a Pokémon Claude skill.
This skill is not about controlling an emulator with Claude; it’s a project that emulates Pokémon itself using Claude Code.
As I mentioned in the README, this is an experimental project. To make it properly, the prompt would need to be refined further, and in some ways it also depends on future model improvements.
Until now, I hadn’t really used Claude Code. While using it, it was my first time having an opportunity to spend this many tokens. Out of that, and from a mix of different daydreams and ideas that came to mind, this project happened. The things I found myself thinking about were:
 1. I once read an article along the lines of “What if computing resources were infinite,” and it stuck with me.
 • If I had unlimited tokens (both context and usage), and an infinitely fast LLM, what could I do?
 2. Simulating a computer inside Minecraft.
 3. A colleague’s idea of wanting to make a game with Claude led me to wonder: what if Claude itself became the game?
 4. I wanted to build something useless—but fun.
 5. Claude isn’t just a code-generation model; it’s a protocol that can access my computer.
 6. How deterministic can we make an LLM through Claude skills?
With these simple thoughts and fantasies, I started looking for a project I’d enjoy building—something that explores what might be possible right now—and began implementing it.
Some people might think this is similar to services like character.ai, but I hope you’ll see it as an experimental project made through Claude skills, and that it becomes an opportunity to expand your own imagination. (On macOS, running the skill also plays background music!)
It’s still unfinished, and I’m not sure whether I’ll continue developing it—but I’d be happy if you take it simply as “Oh, this is something you can do,” at least once.
This translation was written in Korean first and then translated using ChatGPT.

value: Show HN: Pokémon Claude skill (emulates Pokémon itself using Claude Code.)

author: devjelly


value: vishal-ds

value:
We’re building Largemem, (https://largemem.com) a shared knowledge base where groups upload and maintain a common set of documents (PDFs, scans, audio) and query them conversationally.
Each group has its own persistent knowledge base. We parse content into chunks, extract entities, and combine vector search with a lightweight knowledge graph, so answers can synthesize information across multiple documents and across the group’s shared context - not just retrieve isolated snippets.
We would love to hear your feedback!

value: Show HN: AI-Augmented Memory for Groups

author: vishal-ds

title: Show HN: AI-Augmented Memory for Groups


value:
I built this tool during the last league and decided to open source it since we just started this new league. It is just a native interface for saved searches. It uses the same functionality you can get from the trade website by tracking searches via web sockets. But rather than having multiple tabs, it is in a native interface and saves the searches to local storage.
It even implements the 'tap to travel' functionality!
The downside is the setup is kind of technical (have to inspect the console to grab your token), and adding searches is done via pasting JSON. I usually just do a search, then look at the network requests and grab the JSON that way.
I might try to figure out a better way, but meh, it works.

value: Show HN: POEFlip – Path of Exile 2 web socket search monitor (macOS)


value: Elemenopi

value:
Author here. After building my third MCP server and spending another weekend on deployment configs, I got frustrated enough to build Skyz (skyz.ai).
The tutorial walks through building a weather MCP server that connects to VS Code in 7 minutes. The pattern works for any MCP server - database connectors, API integrations, internal tools.
I've seen teams use this for Notion search, Shopify order lookup, and PostgreSQL analytics. The code is standard Node.js/TypeScript, so no vendor lock-in.
Happy to answer questions about MCP, the deployment process, or how we handle the infrastructure!

value: Show HN: Skyz AI – Deploy MCP servers like you'd deploy to Vercel

author: Elemenopi


value: Show HN: I built my portfolio site inspired by the world's first website


value: uyendo

value:
Hi HN,
I just shipped my second iOS app, CozySleep, a baby sleep sounds app.
I built it because my baby had trouble sleeping
The app includes:
- White noise & fan sounds
- Nature, womb, and gentle motion sounds
- Smart timers with fade-out
- Background playback
- Fully offline support
It’s intentionally simple and focused on what parents actually need at 2am.
I’d love any feedback, especially from parents or fellow indie iOS devs.
App Store link: https://apps.apple.com/us/app/id6745897667

value: Show HN: CozySleep – baby sleep sounds app I built to solve my own problem

author: uyendo


value: rasinmuhammed

value:
Hey HN, I’m the author.
I built Misata because existing tools (Faker, Mimesis) are great for random rows but terrible for relational or temporal integrity. I needed to generate data for a dashboard where "Timesheets" must happen after "Project Start Date," and I wanted to define these rules via natural language.
How it works:
LLM Layer: Uses Groq/Llama-3.3 to parse a "story" into a JSON schema constraint config.
Simulation Layer: Uses Vectorized NumPy (no loops) to generate data. It builds a DAG of tables to ensure parent rows exist before child rows (referential integrity).
Performance: Generates ~250k rows/sec on my M1 Air.
It’s early alpha. The "Graph Reverse Engineering" (describe a chart -> get data) is experimental but working for simple curves.
pip install misata
I’d love feedback on the simulator.py architecture—I’m currently keeping data in-memory (Pandas) which hits a ceiling at ~10M rows. Thinking of moving to DuckDB for out-of-core generation next. Thoughts?

value: Show HN: Misata – synthetic data engine using LLM and Vectorized NumPy

author: rasinmuhammed


value: fokdelafons

value:
Hi HN, I'm Jacek, the solo founder behind this project (Lustra).
The Problem: 95% of legislation goes unnoticed because raw legal texts are unreadable. Media coverage is optimized for outrage, not insight.
The Solution. I built a digital public infrastructure that:
1.  Ingests & Sterilizes: Parses raw bills (PDF/XML) from US & PL APIs. Uses LLMs (Vertex AI, temp=0, strict JSON) to strip political spin.
2.  Civic Algorithm: The main feed isn't sorted by an editorial board. It's sorted by user votes ("Shadow Parliament"). What the community cares about rises to the top.
3.  Civic Projects: An incubator for citizen legislation. Users submit drafts (like our Human Preservation Act), which are vetted by AI scoring and displayed with visual parity alongside government bills.
Tech Stack:
Frontend: Flutter (Web & Mobile Monorepo),
Backend: Firebase + Google Cloud Run,
AI: Vertex AI (Gemini 2.5 Flash),
License: PolyForm Noncommercial — source is available for inspection, learning, and non-commercial civic use. Commercial use would require a separate agreement.
I am looking for contributors. I have the US and Poland live. EU, UK, FR, DE in pipeline, partially available. I need help building Data Adapters for other parliaments (the core logic is country-agnostic). If you want to help audit the code or add a country, check the repo. The goal is to complete the database as much as possible with current funding.
Live App: https://lustra.news
Repo: https://github.com/fokdelafons/lustra
Dev Log: https://lustrainitiative.substack.com

value: Show HN: Solving the ~95% legislative coverage gap using LLM's

author: fokdelafons


value: puterbonga

value: Show HN: Octopii – runtime for writing distributed applications in Rust

author: puterbonga


value: iris-digital

value:
It's been a difficult two decades for those of us who expect the products we
buy to respect our freedom and privacy.
We've been marginalized by the mobile revolution for so long that we'd nearly
given up looking for options.
While commiserating recently,
we realized that several important missing pieces of the puzzle have neatly
dropped under our noses while we weren't looking!
What are they?
Well, the Fairphone6 w/eOS, Furilabs FLX1s, Starlite Tablet, new Framework
laptops, OpenWRT One, and a number of others are already shipping.
Software options are plentiful as well.
The landscape has changed significantly in a few short years.
Of course, these products are not perfect.
Right now you might be counting their flaws.
But we feel there's a another way to look at the situation.
One long-term view is that these respectful options are now good enough for the
vast majority of folks—and they'll only get better,
if further invested in.
The catch?
One needs to wrangle numerous products from almost as many companies.
That's tedious for normal folks and busy geeks alike,
plus it splits investment into small portions.
So, how can we get these organizations to work together?
We've brainstormed some ideas, such as a unified storefront, licensing,
mergers, etc,
but don't know how feasible they are.
What do y'all think?
If we can help these products get attention,
increase sales,
and further investment,
we'll complete a libre product line that much faster.
(These goals are detailed
at "The Ethical Computing Initiative,"
https://aol.codeberg.page/eci/ ).
TL;DR—The products are listed at: https://aol.codeberg.page/eci/status.html
Now they need our support!

value: Show HN: There's now a full suite of open hardware available

author: iris-digital


value: qmarchi

value:
I was talking with a friend (@finnvoid) about how we could make it easier to practice their hiragana and katakana reading while they are living in Japan. After some quick basic idea-crafting with Gemini, they took it and ran with to, building "Jordle" a Wordle-esque tool to help them (and you) learn your furigana.
Playing is easy, your goal is to transliterate the shown characters into the romaji (romanization). Pick between the two character sets (hiragana and katakana) or both to practice.
Data is local to the device, so it's pretty snappy and technically works offline.
We'll probably be hanging out in the comments for a bit if people have questions or comments!

value: Show HN: Jordle – Japanese Furigana Practice

author: qmarchi


value: andrelinhk

value:
Hello HN! We’re a small team from NUS (undergrad + PhD). PaperDebugger started as a research project and evolved into an open-source tool that integrates directly into Overleaf as an academic writing assistant. It provides LaTeX-aware debugging, reviewer-style feedback, and targeted revision suggestions without leaving the editor, ideal for users who already write and collaborate on projects in Overleaf.
A small beta release picked up more traction than we expected over the past week. It’s far from perfect but since people are already trying it, we decided to share it more widely and prioritise stability, reliability, and gathering feedback earlier than planned.
There’s no signup: install the Chrome extension and it attaches immediately to your Overleaf project. You can highlight any section and receive specific suggestions, issue reports, or multi-step revision passes. Under the hood, it reads your project structure and is powered by our custom MCP-based orchestration engine that simulates a Research → Critique → Revision workflow rather than a single chat prompt.
Try it:
Chrome extension (Overleaf integration):
https://chromewebstore.google.com/detail/paperdebugger/dfked...
Landing page (demo + overview):
https://www.paperdebugger.com/
What we’re looking for:
• Whether the Overleaf-embedded workflow is actually more useful than copy/paste LLM editing
• Thoughts on UX and interaction inside the Overleaf editor
• Any concerns, e.g., about privacy or extension behaviour (we do have a policy published)
• Feature requests that would help with conference/journal submissions (we’re currently working on a formatter, citation verifier)
For readers interested in the technical details and research background that motivated the system, here’s a link to the paper: https://arxiv.org/abs/2512.02589
Happy to answer questions about the architecture, MCP design, prompts, or anything else.

value: Show HN: PaperDebugger – An Overleaf companion for revising LaTeX papers

author: andrelinhk


value: jarusll

value: Show HN: Tokri – a desktop basket for temporary files, text, and images

author: jarusll


value: KirisameMarisa

value:
I built VideoReview to reduce review overhead for team members working on game cutscenes, skits.
It lets collaborators leave time-based comments, draw directly on video frames, and discuss feedback in a lightweight, SNS-like interface.
Integrations include JIRA (create tasks from comments) and Slack (share comments).
I’d love feedback on usability from people who review game or animation footage!

value: Show HN: VideoReview – Collaborative video review for games and animation

author: KirisameMarisa


value:
Hi HN,
I’m sharing BrowserWing, an open-source experiment exploring a more efficient way for AI agents to control browsers.
Most browser-based agents today rely on frequent LLM interactions for DOM inspection, screenshot reasoning, and step-by-step execution. While this works, it’s slow and consumes a large number of tokens.
BrowserWing takes a different approach. Browser automation is implemented once as scripts and then exposed as MCP commands. AI agents focus on expressing intent and simply call these commands, instead of interacting with the browser step by step.
This significantly reduces interaction latency and token usage, while keeping browser execution deterministic and controllable.
This is an early release, focused on validating the idea rather than feature completeness. I’m especially interested in feedback from people building AI agents, browser automation, or MCP-based tools.
Repo: https://github.com/browserwing/browserwing
Thanks for reading.

value: Show HN: BrowserWing – Turning Browser Actions into MCP Commands


value: nicoloboschi

value: Show HN: Hindsight Is the New SOTA Memory for AI Agents

author: nicoloboschi


value: dawitworku

value:
xsql is an open-source Rust CLI + TUI for converting SQL schema DDL
between database dialects.
Instead of text-based rewrites, it parses CREATE TABLE statements into a
small intermediate representation (IR), then emits equivalent SQL for the
target dialect. This makes conversions safer, testable, and easier to extend.
It supports single-file and recursive folder conversion, includes a
no-typing interactive TUI, and recently added an experimental IR v2 with
constraint support and JSON output for CI and tooling use.
Feedback is very welcome, especially on schema portability and IR design.

value: Show HN: Xsql – Convert SQL Schemas Across MySQL, Postgres, and SQLite

author: dawitworku


value:
On MacOS Sequoia, under "Other Updates", it now pre-selects "macOS Tahoe 26.2" instead of the macOS Sequoia update.
These were the pre-selected checkboxes when I opened the dialog:
https://ibb.co/GfMw9ghL
They hide Tahoe it in the summary text too:
https://ibb.co/wZWb46CV
So to continue receiving updates for Tahoe, you have to now select the correct checkboxes.
This is really sneaky.

value: Show HN: New macOS dark pattern to force Tahoe upgrade


value: Show HN: Single-file, offline-first Kitchen OS for chefs (No SaaS, No Cloud)


value: tsazan

value:
Hi HN, author here.
I built CommerceTXT because I got tired of the fragility of extracting pricing and inventory data from HTML. AI agents currently waste ~8k tokens just to parse a product page, only to hallucinate the price or miss the fact that it's "Out of Stock".
CommerceTXT is a strict, read-only text protocol (CC0 Public Domain) designed to give agents deterministic ground truth. Think of it as `robots.txt` + `llms.txt` but structured specifically for transactions.
Key technical decisions v1.0:
1. *Fractal Architecture:* Root -> Category -> Product files. Agents only fetch what they need (saves bandwidth/tokens).
2. *Strictly Read-Only:* v1.0 intentionally excludes transactions/actions to avoid security nightmares. It's purely context.
3. *Token Efficiency:* A typical product definition is ~380 tokens vs ~8,500 for the HTML equivalent.
4. *Anti-Hallucination:* Includes directives like @INVENTORY with timestamps and @REVIEWS with verification sources.
The spec is live and open. I'd love your feedback on the directive structure and especially on the "Trust & Verification" concepts we're exploring.
Spec: https://github.com/commercetxt/commercetxt
Website: https://commercetxt.org

value: Show HN: CommerceTXT – An open standard for AI shopping context (like llms.txt)

author: tsazan


value: josheverett

value:
Building onboarding was a huge pain when I was head of customer success for a SaaS. It required design and dev time, and editing it later required more design and dev time. We knew it was important to build good onboarding, we just didn't have the time or bandwidth to do it well
So I made a tool that makes it easy for non-technical people to build onboarding flows with things like checklists, modal popups, and guided highlighting in the app
Honestly our UI isn't amazing and maybe my friends and I will be some of the only people who ever use this, but figured I'd share it around and see if anyone else is interested
If this gets any traction then I'll want to improve the UI, improve the preview feature, and perhaps add more methods of onboarding. I'd love to add things like surveys, happiness indicators (like click here for smiley face, click here for sad face), automatic notifications to customer support teams if the user follows certain steps...
So we'll see :) here's the link (https://www.joinahoy.com/) Let me know if there's anything you'd like to see in this project?
Thanks for your time!

value: Show HN: I made a tool to make user onboarding easier

author: josheverett


value: hkh

value:
Hey folks, I’m Hassan, one of the co-founders of Infracost (https://www.infracost.io). Infracost helps engineers see and reduce the cloud cost of each infrastructure change before they merge their code.
The way Infracost works is we gather pricing data from Amazon Web Services, Microsoft Azure and Google Cloud. What we call a ‘Pricing Service’, which now holds around 4 million live price points (!!). Then we map these prices to infrastructure code. Once the mapping is done, it enables us to show the cost impact of a code change before it is merged, directly in GitHub, GitLab etc. Kind of like a checkout-screen for cloud infrastructure.
We’ve been building since 2020 (we were part of YC W21 batch), and iterating on the product, building out a team etc. However, back in 2020 one of our users asked if we can also show the carbon impact alongside costs.
It has been itching my brain since then. The biggest challenge has always been the carbon data. The mapping of carbon data to infrastructure is time consuming, but it is possible since we’ve done it with cloud costs. But we need the raw carbon data first. The discussions that have happened in the last few years finally led me to a company called Greenpixie in the UK. A few of our existing customers were using them already, so I immediately connected with the founder, John.
Greenpixie said they have the data (AHA!!) And their data is verified (ISO-14064 & aligned with the Greenhouse Gas Protocol). As soon as I talked to a few of their customers, I asked my team to see if we can actually finally do this, and build it.
My thinking is this: some engineers will care, and some will not (or maybe some will love it and some will hate it!). For those who care, cost and carbon are actually linked; meaning if you reduce the carbon, you usually reduce the cost of the cloud too. It can act as another motivation factor.
And now, it is here, and I’d love your feedback.
Try it out by going to https://dashboard.infracost.io/, create an account, set up with the GitHub app or GitLab app, and send a pull request with Terraform changes (you can use our example terraform file). It will then show you the cost impact alongside the carbon impact, and how you can optimize it.
I’d especially love to hear your feedback on if you think carbon is a big driver for engineers within your teams, or if carbon is a big driver for your company (i.e. is there anything top-down about carbon).
AMA - I’ll be monitoring the thread :)
Thanks all

value: Show HN: See the carbon impact of your cloud as you code

author: hkh


value:
I built a framework that destroys binary file formats into chunks that evade detection, then executes them directly from memory without writing files.
Validation: Original binary gets 58/72 detections on VirusTotal. Format-destroyed chunks get 0/62. Reconstruct it, 58/72 again with byte-perfect hash match. It's deterministic.
It's not encryption (no file structure remains), not obfuscation (format is destroyed, not hidden), not packing (no stub loader needed).
Test battery: 75% success rate. Console apps, network tools, crypto, and threading work. GUI apps and DLLs don't (documented in KNOWN_LIMITATIONS.md).
Includes working C2 beacon executing from chunks.
MIT licensed. Full source on GitHub. Would love to find edge cases or binaries that break it.

value: Show HN: Veriduct Prime – Format destruction framework for binary evasion


value: Show HN: Mesh – Team chat on Nostr using NIP-29 relays (Rust and Next.js)


value: uptownhr

value: Show HN: MCP Agentic UI with XState and WebSockets

author: uptownhr


value: logicallee

value:
This is my writeup of a new AI-generated web browser. It barely works but you can use it to post on my forum.
You can vote on feature ideas and suggestions here: https://pollunit.com/en/polls/ahysed74t8gaktvqno100g
Happy to answer any questions about it.

value: Show HN: We built an AI-Generated Browser That Works a Little

author: logicallee


value: Show HN: I built a simulation game to practice online self-defense


value:
  My partner and I (ex-Googlers) plan our trips around food as a way to connect with local culture. Before every trip, we'd spend hours digging through Reddit threads and local blogs, filtering out sponsored noise to find places worth eating.

  So we built CuriousSpoon, a food guide we could actually trust.

  *Why ratings fail*

  - 51% of negative reviews cite service, only 31% cite food [1]

  - Google removed 170M fake reviews in 2023; Harvard found 16% are suspicious [2]

  *What we built instead*

  An engine that does what a local food nerd does: reads city newspapers, local critics, subreddits, chef interviews. Surfaces spots generating real buzz. Demotes the ones coasting on old reputation. Filters out the famous-but-meh.

  Refreshed regularly. No paid placements. No sponsored content.

  *What's live*

  - 15 cities (SF, NYC, Paris, Rome, Tokyo,...)

  - 70+ spots per city

  - Walkable food crawls with specific dishes to order

  - Free, mobile-friendly

  We tested this ourselves in Lyon, Bologna, and Rome. In Rome, we skipped the long lines at a famous sandwich spot and ate instead at a quiet local place nearby. In Bologna, we found a bring-your-own-food Osteria where we picked up dishes from a nearby market. It ended up being my favorite meal of the year.

  Looking for feedback: what features would make this actually useful on your next trip?

  [1] https://gatherup.com/blog/online-reviews-study-restaurants-reviews/

  [2] https://www.hbs.edu/faculty/Pages/item.aspx?num=45151

value: Show HN: A food guide that ignores Google and Yelp ratings


value: Show HN: I built a local AI Compliance Officer because my database had bad data


value: williamhaw

value:
Hi HN! I’m an engineer at Artie where we do real-time data replication.
We were adding MotherDuck as a destination and the first version just used DuckDB’s Go driver directly. It worked great on my machine… until we wired it into our Transfer service (https://github.com/artie-labs/transfer).
Because the driver requires CGO, our cross-compiles to amd64 and arm64 started failing, we lost our easy static binaries, and our Docker images had to pull in C toolchains and system libraries just to support one dependency. We tried isolating the CGO bits in a separate module, but it still caused CI failures and forced us to rewrite chunks of our build pipeline. At that point it was clear we didn’t want CGO anywhere near our main service.
So I built ducktape: a tiny standalone microservice that wraps DuckDB’s Appender API behind HTTP/2 streams. Clients stream NDJSON over HTTP/2, and ducktape appends directly into DuckDB on the other side. No CGO in the main codebase, and we keep our cross-platform, pure-Go build story.
The overhead was surprisingly low in benchmarks: ~757 MiB/sec over HTTP/2 vs ~848 MiB/sec in-process — about 90% of native performance but over the network.
ducktape is open source and MIT licensed: https://github.com/artie-labs/ducktape
I’d love feedback, especially if you’ve tackled CGO isolation differently or have ideas to squeeze out more performance!

value: Show HN: Ducktape – a tiny HTTP/2 wrapper around DuckDB's Appender API

author: williamhaw


value: kneesdev

value: Blinze is an open-source web browser optimized for performance and privacy. Designed for developers and built on modern web standards. Uses CEF with a custom rendering layer, built in C++, Rust, and TypeScript.

value: Show HN: Blinze Browser – A browser optimized for development

author: kneesdev


value: Show HN: Vibe coding agent – focussing on internal tools


value: lombarovic

value:
Hi HN,
I built the first version of Drawize back in late 2016 specifically for a Samsung Tizen OS app contest. I crunched and built the whole thing (including the real-time multiplayer engine) in under 4 weeks.
It didn’t win anything in the contest.
Since it was built with web tech anyway, I published it on the open web in early 2017 just to see what would happen. It started living its own life, and today — 8 years later — the database processed the 100,000,000th drawing.
On the busiest days it’s been 30k+ active users, and storing 100M drawings currently sits at ~3.16 TB.
The milestone moment: I was watching live logs today, terrified the 100Mth drawing would be NSFW. Luckily, the RNG gods smiled and it turned out to be a Red Balloon
(You can see the 100Mth drawing here: https://www.drawize.com/blog/100-million-drawings-milestone)
Tech stack (boring but fast):
Backend: .NET + WebSockets (real-time sync)
Frontend: hand-coded HTML/JS + jQuery (no React, no bundlers)
Data: PostgreSQL & MongoDB
Storage: Wasabi Cloud (moved there to save on S3 costs)
Scaling as a solo dev: real-time lobbies + reconnection edge cases + moderation/content filtering. I use content classification models trained in 2021 to filter bad content, and the real-time multiplayer side is mostly highly optimized .NET code.
Happy to answer questions about the “failed” Tizen origin, real-time multiplayer on the web, moderation, or how .NET handles the load.

value: Show HN: My Tizen multiplayer drawing game flopped, but then hit 100M drawings

author: lombarovic


value: durch

value:
Claude Code will solve your problem. It might also refactor three files, add "future flexibility," and solve two problems you didn't mention. Superego blocks that.
It is a Rust CLI that hooks into Claude Code's lifecycle. Before large edits or before Claude finishes, another LLM evaluates the work against one question: is this the simplest thing that actually solves the stated problem?
When something's off, Claude is blocked and shown feedback like:
"This may be a local maximum. What alternatives were considered?"
"Is this necessary right now? This seems to solve [hypothetical problem] rather than [actual need]."
Claude then tries to self-corrects, often proposing something simpler or asking clarifying questions it should have asked upfront.
The philosophy: Every line of code is a liability. Every abstraction is a loan. If you can't explain it simply, it's too complex. If it feels clever, be suspicious.
Tradeoffs: Yes, this adds LLM calls. In my experience the tighter results are worth it, but YMMV.
Install:
  cargo install superego
  # or
  brew install cloud-atlas-ai/superego/superego

  sg init && claude

The prompt is customizable. The default is opinionated toward simplicity—because the alternative is an AI that confidently builds cathedrals when you asked for a shed.
Source-available (free for personal/research use). GitHub: https://github.com/cloud-atlas-ai/superego

value: Show HN: Superego – An AI that watches Claude Code and blocks over-engineering

author: durch


value: j-raghavan

value:
- The problem:
  Compliance teams ask: “Which agent accessed what, and when?” Existing proxies treat all agent traffic the same—no per-agent identity, no enforceable time bounds, weak audit trails.
- What it does
  - Agent → Envoy (mTLS per-agent cert) → OPA (policy check) → Target
  - Each agent gets a short-lived cert, rotated automatically
  - Policies constrain domain + time window; outside-window requests are denied and logged (<5ms median in demo)
  - Audit logs are hash-chained; here’s how to verify the chain: https://github.com/j-raghavan/ChronoGuard#verify-audit-chain
- Why not SPIFFE/Boundary/etc.?
  They handle identity; ChronoGuard adds enforced time windows + tamper-evident audit (“agent X can only hit api.example.com 9–5 UTC”).
- Try it (pick one)
  - Live demo (2 min): https://j-raghavan.github.io/ChronoGuard/ — see 9–5 allowed, after-hours denied, with audit trail
  - One-click Codespaces: https://codespaces.new/j-raghavan/ChronoGuard — brings up Envoy+OPA; follow the 3-step README
  - Repo: https://github.com/j-raghavan/ChronoGuard
- Scope
  - Covers: per-agent identity (mTLS issuance/rotation), time-bounded access control, tamper-evident audit
  - Not yet: model jailbreak defense, data loss prevention—this is access control + audit
- Looking for contributors
  Envoy filters/hot-reload certs, OPA policy packs, language SDKs (LangChain/AutoGen), audit verification tooling. Good first issues: https://github.com/j-raghavan/ChronoGuard/labels/good%20firs...
- Best starting point: the live demo. Feedback or PRs welcome.

value: Show HN: ChronoGuard – Time-bounded access control for AI agents (open source)

author: j-raghavan


value: bbx

value:
I find that the drag and drop experience can quickly become a nightmare, especially on mobile.
To tap, hold, drag, and scroll, all at the same time, is both difficult to achieve, and prone to errors.
I've always had in mind this 2-step approach, where picking an element and placing it were two separate steps.
So I implemented this basic version to showcase my idea.
While it might take more time than a regular drag and drop, the benefit is for people who struggle with holding down the mouse button. With picknplace.js, you only need two clicks and some scrolling.
This solution is meant as an experiment, so I'm open to discussion.

value: Show HN: Picknplace.js, an alternative to drag-and-drop

author: bbx


value: carlopi

value: DuckDB Table Visualizer demo, showcasing 'Iceberg on the Browser' demo (https://duckdb.org/2025/12/16/iceberg-in-the-browser)

value: Show HN: DuckDB Table Visualizer –> Iceberg

author: carlopi


value: mraspuzzi

value:
I run Hardware Meetup (40+ cities) and many hardware startups are looking for software engineers but are having a hard time figuring out fit.
So I built this over a couple weeks to see if past projects could work better.
The flow:
1. You add your best GitHub repo
2. It reviews your code and scores it 1-100 with actual feedback
3. Reviews your LinkedIn for experiences in building and project history (not just job titles)
4. Pick a role you're looking at
5. It creates a fit score from the two
Planning to add multi-repo support, actual contribution tracking, and other portfolio formats (websites, PDF, etc).
Curious to hear:
1. Is the code review useful or not yet?
2. Does a composite score even make sense here?
3. For hardware founders here, when hiring, what do you wish you had beyond a resume?
This is a super rough v1. Please roast.

value: Show HN: Code Review for Hardware Startup Fit

author: mraspuzzi


value:
Hi HN,
A few months ago while on a backpacking trip in Yosemite, my friend Tony and I were talking about how cool it would be if you could run any coding agent in parallel through a TUI. We worked on a solution using tmux + worktrees for a few months, and then discovered the Agent Client Protocol (ACP) from Zed!
ACP provides a “standardized protocol for agent-editor communication, similar to how the **Language Server Protocol (LSP) standardized language server integration” (https://agentclientprotocol.com/overview/introduction).
We threw away what we had built and decided to fork OpenCode to turn it into an terminal based ACP client (OpenCode itself has ACP support, so you can run OpenCode in OpenCode!).
ACP in the terminal gives you a single scriptable interface to any agent that you can run headlessly with `-p`, pipe input/output, or integrate directly into CI.
We're building Forge (still in alpha) to explore what terminal-native ACP unlocks. It's still early, but we're curious what patterns others see here.
Try it out and let us know what you think: https://github.com/forge-agents/forge

value: Show HN: Forge – Universal CLI for coding agents, powered by ACP


value: chilarai

value:
Hi HN,
I kept running into the same problem as a developer: API docs are often incomplete, outdated, or hard for both humans and AI to reason about. In practice, the real source of truth is usually the API surface itself, whether that's OpenAPI/Postman today or SDKs in the near future.
So I built Swytchcode, a tool that converts real API definitions into a structured spec that AI can use to generate integration code, workflows, and tests.
How it works today:
- Ingests OpenAPI & Postman specs (including large, real-world ones like Stripe)
- Normalizes endpoints, inputs, outputs, and error responses into a single spec (we call it a Wrekenfile)
- Uses that spec for AI-powered discovery, code generation, and workflow construction
What's coming next:
- Direct SDK parsing (Go, TypeScript, Python) to extract public methods and types
- Using SDKs as a source of truth when docs or specs are missing or outdated
- Deeper workflow and authentication discovery from real code paths
Why this approach:
- Docs drift over time
- Specs are better but often incomplete
- SDKs tend to reflect what actually works in production
- AI needs precise, machine-readable context to generate correct code
This is still early, but we're seeing steady developer usage, daily signups, and active conversations with API teams about integrating their APIs.
I'd love feedback from the HN community:
- Does this approach make sense?
- Where do you think SDK-based parsing could break down?
- What would you expect from a tool like this?
Happy to answer any technical questions.
Website: https://swytchcode.com
Playground with Stripe (demo): https://playground.swytchcode.ai

value: Show HN: 24x7 AI support engineer for APIs

author: chilarai


value: We built live AI evaluation to detect hallucinations, grounding issues, and drift as outputs are generated. This helps teams move GenAI from pilots into production.

value: Show HN: Live AI Evaluation to Detect Hallucinations in Real Time


value: sivann

value:
Kafkatop is a handy real-time monitoring CLI tool for Apache Kafka, that displays consumer lag and event rates in a clean, top-like interface. It can assess when consumers will catch up, and provides indicators for partition distribution health
v2 is a go rewrite from the original Python PEX. The main reason was the python version dependency on confluent's librdkafka which was not maintained any more for older systems. The new implementation is pure GO (franz-go, no CGO deps) meaning it's very safe to distribute.
The new features include:
* drill into partition details: config, lag, offsets, rates, replicas, ISR status, and leaders, with Cell colors indicating hotness
* partition health with two new metrics:

  - PAR (Peak-to-Average Ratio): shows if one partition is 5x, 10x, or 200x busier than average

  - Cv (Coefficient of Variation): measures overall topic skew from 0 (perfect) to >1 (critical)

* improved catch-up ETA calculation: accounts also for arrival rate
* better performance: parallel API calls with configurable concurrency (default 10 concurrent)
* custom DNS mappings: override DNS resolution for broker-provided kafka nodes allowing to work via port-forwarding.
The tool is here: https://github.com/sivann/kafkatop
Would love feedback, especially on the partition metrics - are PAR and Cv intuitive enough, or should I add different indicators? What other feature would you like to see?

value: Show HN: Kafkatop 2.0 – top for Kafka – rewritten in Go with partition analytics

author: sivann


value: andrewsthoughts

value:
Hi HN, I’m Andrew, Founder of Zencoder.
While building our IDE extensions and cloud agents, we ran into the same issue many of you likely face when using coding agents in complex repos: agents getting stuck in loops, apologizing, and wasting time.
We tried to manage this with scripts, but juggling terminal windows and copy-paste prompting was painful. So we built Zenflow, a free desktop tool to orchestrate AI coding workflows.
It handles the things we were missing in standard chat interfaces:
Cross-Model Verification: You can have Codex review Claude’s code, or run them in parallel to see which model handles the specific context better.
Parallel Execution: Run five different approaches on a backlog item simultaneously—mix "Human-in-the-Loop" for hard problems with "YOLO" runs for simple tasks.
Dynamic Workflows: Configured via simple .md files. Agents can actually "rewire" the next steps of the workflow dynamically based on the problem at hand.
Project list/kanban views across all workload
What we learned building this
To tune Zenflow, we ran 100+ experiments across public benchmarks (SWE-Bench-*, T-Bench) and private datasets. Two major takeaways that might interest this community:
Benchmark Saturation: Models are becoming progressively overtrained on all versions of SWE-Bench (even Pro). We found public results are diverging significantly from performance on private datasets. If you are building workflows, you can't rely on public benches.
The "Goldilocks" Workflow: In autonomous mode, heavy multi-step processes often multiply errors rather than fix them. Massive, complex prompt templates look good on paper but fail in practice. The most reliable setups landed in a narrow “Goldilocks” zone of just enough structure without over-orchestration.
The app is free to use and supports Claude Code, Codex, Gemini, and Zencoder.
We’ve been dogfooding this heavily, but I'd love to hear your thoughts on the default workflows and if they fit your mental model for agentic coding.
Download: https://zencoder.ai/zenflow
YT flyby: https://www.youtube.com/watch?v=67Ai-klT-B8

value: Show HN: Zenflow – orchestrate coding agents without "you're right" loops

author: andrewsthoughts


value: Show HN: PgEdge Anonymizer – for replacing PII in test databases from prod


value: alex-russo

value: I've written a crate (https://crates.io/crates/rconvolve) and a little demo using WebAssembly. The demo allows a full workflow of generating a sine sweep, recording that sweep in a room, extracting an IR from the recording, and applying it to your microphone or other input device in real time to see how it sounds. This is my first open source project and I did it just for fun, but I'd love to hear if anyone tries it out. I'm working on a VST plugin based on this crate as well which I plan to open source.

value: Show HN: Rconvolve – Fast audio convolution and IR extraction built with Rust

author: alex-russo


value: peterhddcoding

value: Show HN: Pothole Detection System (YOLOv8 – FastAPI – Docker – React Native)

author: peterhddcoding


value: amirkabbara

value:
A few months ago, we launched Papr — a predictive memory layer for AI agents. It helps agents remember conversations, documents, and context over time, so they don’t start from scratch on every interaction. Instead of just storing information, Papr learns the connections between memories and surfaces the right context in real time, exactly when it’s needed.
Today, we’re building on that foundation. We’re introducing Papr Context Intelligence — the ability for agents to not only remember context, but to make sense of it: to reason over information, generate insights, and understand what changed and why.
Here’s a simple example of what that means in practice.
Imagine an AI assistant helping a customer support team.
Before context intelligence, the assistant can retrieve past tickets and related conversations. If you ask, “Why is this customer frustrated again?”, it might surface previous messages or similar issues — leaving a human to piece together what actually happened.
With Papr Context Intelligence, the assistant understands the situation. It can explain that the customer experienced the same login issue last month, that the original fix didn’t fully resolve it, and that a recent change reintroduced the problem. It can also tell you that 37 other customers are currently reporting the same issue, that reports spiked after the latest release, and that most affected users are on the mobile app.
Instead of just showing history, the agent explains what changed, why it’s happening, and how widespread the issue is — helping teams respond faster and decide what to prioritize.

value: Show HN: Beyond RAG: Introducing Papr Context Intelligence

author: amirkabbara


value: admtal

value:
I built this because I couldn’t find it.
Wanted to record demos of my web game with my face on screen. iOS screen recording doesn’t do face cam. Loom is desktop only. OBS is a whole thing.
So I made Demo Scope.
Load any mobile site in the built-in browser, hit record. Face cam is draggable and resizable. Touch indicators show every tap. Also does streaming, annotations, and narration over videos/photos from camera roll.
Free to try. $9.99 one-time. No subscription.
Marketing site: https://demoscope.app
App Store: https://apps.apple.com/app/demo-scope/id6755395174
Would love feedback.

value: Show HN: Demo Scope – Mobile screen recorder with face cam and touch indicators

author: admtal


value: garywgrimes

value: I made a sports matchup database with a UI sitting on top as a learning experiment using native SMS capabilities for "network distribution." No real money changes hands, no picks for sale, virtually no user tracking -- just a database with a UI that generates dynamic SMS links. Been kicking around the idea for over 10 years and stuck on the DB part till recently. I'm curious whether it's possible to build and support something like this on a low operating budget and without hard-to-justify subscription models and predatory user event tracking/re-engagement strategies. I’d love honest feedback on what feels useful, misleading or unnecessary, or what could make it more compelling.

value: Show HN: Sports Database as SMS linking experiment

author: garywgrimes


value: ykdojo

value: Show HN: Claude Code Tips

author: ykdojo

title: Show HN: Claude Code Tips


value: mohamedattahri

value: Show HN: Simple Go iterator-based backoff library

author: mohamedattahri


value: langarus

value:
I built this browser extension to help deal with the mess of after a research/work.
I always run into this issue that I have a million tabs open and then have to manually go through each to see if I still need it or not. So it ends up being work after work.
That's why I built this little extension to give you an overview of what you have and help you apply bulk actions to them.
If you have some time give it a go, feedback is much appreciated :).
No sign-ups, no logs, 100% free
Firefox: Tab Tangle – https://addons.mozilla.org/en-US/firefox/addon/tab-tangle/
Chrome: https://chromewebstore.google.com/detail/tab-tangle/glflinnn...
Edge: https://microsoftedge.microsoft.com/addons/detail/tab-tangle...

value: Show HN: Tab Tangle a browser extension to help clean up tab hoarding

author: langarus


value: flashgordon

value:
I've been building services where the API layer and database layer inevitably drift apart. Different field names, timestamps as int64 vs time.Time, nested messages becoming JSONB columns - the usual pain.  I got a bit sick of hand-writing the same boilerplate converters between my API protobufs and GORM/Datastore entities, so I built this.
Yes - coupling API and DB schemas isn't always best practice. Your API should evolve independently of storage. Leaking internal details to clients is bad. DB optimizations (denormalization, indexes) shouldn't dictate your API shape.   But really for a lot of the services Ive bene building - especially at the early stages - there is a lot of "similarity" - 80-90%.   Id be doing the same `user.Name = dbUser.Name` lines hundreds of times, and the "clean separation" was mostly ceremony.   And the drift just caused more bugs early on - you know forgetting to update a converter when adding a field, subtle type mismatches, copy-paste errors and so on.
This lets me have a single source of truth for my schemas and declare "transformations" as it goes through the layers and the target models/converters are also generated.   You could use something like tRPC but then you are stuck with a single language eco system.  I really wanted to not have that coupling.   Now I can move fast when the schemas are similar, while still allowing divergence when I need it (decorators for custom logic, explicit field mappings).
Currently I generate targets for GORM (Go) and Google Cloud Datastore (so I can spin up small projects with postgres storage or AppEngine storage).   Definitely rough around the edges and probably missing features you need, but it's been useful for my own projects.    Still lots of things planned (and doing other languages is on the roadmap)
Would love feedback - especially if you've found better patterns for this problem.

value: Show HN: Protoc-gen-dal – Generate data access converters from protobuf

author: flashgordon


value: brucebotsford

value: I build a digital ski bootfitter product because the process of buying new ski boots is terrible.  Answer a few questions, scan your feet with your phone, and get 3 boots recommended for you (with links to purchase) all in 5 minutes or less.

value: Show HN: Digital Ski Bootfitter

author: brucebotsford

title: Show HN: Digital Ski Bootfitter


value: broxytr

value:
Hey HN, OP here.
I built this because I was frustrated with constant OOM crashes trying to run Qwen-2.5-7B and Llama-3 models on my local GTX 1050 (4GB).
I realized that standard GGUF quantization tools often add unnecessary padding to tensors, pushing VRAM usage just over the 4GB limit due to fragmentation. QKV Core solves this via what I call "Surgical Alignment"—it analyzes layer entropy to switch between dictionary coding and raw storage, and then trims padding bytes to strictly adhere to block boundaries (e.g., 110-byte alignment for Q3_K).
This approach shaved off enough overhead to fit 7B models comfortably into 4GB VRAM and resulted in a ~34% improvement in I/O load times thanks to the aligned memory blocks and Numba-accelerated kernels.
The project is open source (MIT). I'd love to hear your feedback on the quantization logic or answer any questions about the implementation!

value: Show HN: QKV Core – Run 7B LLMs on 4GB VRAM via surgical memory alignment

author: broxytr


value: aarnelaur

value: Don't build forms from scratch. Ask ChatGPT, Claude, or Gemini to write a survey, paste the text, and get a professional, shareable form in seconds.

value: Show HN: Let ChatGPT create interactive forms and surveys for you

author: aarnelaur


value: Show HN: Open Source B2B SaaS Starter Kit (Go, Next.js, RBAC, Polar)


value: After 17 failed startups, built this solving our own problem integrating AI agents with my clients banking systems. Hopeless api helps turn SOAP/XML into clean REST JSON for AI agents also with ~70% token cost reduction.

value: Show HN: AI middleware that translates SOAP/XML – REST and reduces token by 90%


value: vrepsys

value:
Hi everyone,
I built Prose UI while developing a visual editor for MDX (dhub.dev). The problem: every framework represents the same components differently - Docusaurus uses ::: directives, others use <Callout> JSX, etc. This makes it nearly impossible to build portable editing tools or content that works across frameworks.
Prose UI provides a standardized set of React components (callouts, tabs, cards, code blocks, LaTeX math) that work directly in MDX - with or without a framework. Use them in plain Next.js, Docusaurus, or your own setup. The goal is consistent syntax and behavior for portable MDX.
Built this to solve my own problem. Would love feedback!
Repo: https://github.com/vrepsys/prose-ui

value: Show HN: Prose UI - Beautiful styling and components for Markdown prose (OSS)

author: vrepsys


value: AsfhtgkDavid

value:
Hi HN,
WindMouse is a fairly old and well-known algorithm for generating human-like mouse movements (curved paths, variable speed, natural deceleration). It’s often referenced in automation discussions, but surprisingly I couldn’t find a clean, well-tested, reusable implementation as a Python library.
So I decided to implement it myself.
The project is now released as WindMouse:
* Strong typing (NewType for coordinates, mypy-friendly)
* Two backends:

  * PyAutoGUI (cross-platform)
  * AutoHotkey (Windows)

The algorithm itself is not new - the implementation is. My goal was to create something that could be downloaded and immediately used in projects.
I’m looking for help with:
* Testing on different OS setups (especially macOS edge cases)
* New backends (e.g. native macOS, Wayland, low-level Windows APIs, game engines, remote desktops)
* Feedback on API design and parameter defaults
Happy to answer questions about the algorithm, design decisions, or tradeoffs.

value: Show HN: WindMouse Algorithm in Python

author: AsfhtgkDavid

title: Show HN: WindMouse Algorithm in Python


value: gjtorikian

value: Show HN: Gh-actions-lockfile: generate and verify lockfiles for GitHub Actions

author: gjtorikian


value: mribbons

value:
Hi HN,
AI agents excel at web tasks because they can read the DOM. But when you point that same agent at a mobile app, it hits a wall. There is no DOM to read. Some have tried to use computer vision, but it is slow, expensive, and flaky.
I built Agenteract to give mobile apps a "DOM" that agents can actually read.
Instead of taking screenshots, Agenteract instruments your app to "self-report" its view hierarchy through a secure local WebSocket. It serializes the UI into a token-efficient JSON tree.
On top of this, Agenteract provides a clean CLI that enables agents to interact with the app with minimal context overhead.
Here's a normal flow of using the CLI to interact with the app:

  npx @agenteract/agents hierarchy your-app

Simplified response example:

  {
    "status": "success",
    "hierarchy": {
      "name": "main(RootComponent)",
      "children": [
        {
          "name": "ViewStuff",
          "children": [
            { "name": "Text", "text": "Home" },
            {
              "name": "Pressable",
              "testID": "test-button",
              "children": [
                { "name": "Text", "text": "Simulate Target" }
              ]
            }
          ]
        }
      ]
    },
    "id": "296d657e-f5e8-49d1-a7ab-62815a"
  }

Then tapping the button:

  npx @agenteract/agents tap your-app test-button

If the interaction is successful, the agent receives:

  {"status":"success","message":"Tapped test-button"}

Alternatively, the agent could retrieve the view hierarchy again to see the updated state.
We support the following actions:
- tap
- input
- scroll
- longPress
- swipe
- wait
- log
- cmd (send keystrokes to dev servers, eg reload)
Why not just use screenshots?
* Speed: JSON is instant; processing screenshots takes seconds.
* Cost: Text tokens are orders of magnitude cheaper than image tokens.
* Reliability: Deterministic targeting means no hallucinated coordinates.
Supported Platforms:
* React Native / Expo (via Fiber tree introspection)
* Flutter (via Widget tree traversal)
* Native iOS (Swift/UIKit/SwiftUI)
* Native Android (Kotlin)
Repo: https://github.com/agenteract/agenteract
Docs: https://agenteract.io/docs

value: Show HN: Agenteract – Drive mobile apps with LLMs using UI trees (no vision)

author: mribbons


value: Show HN: AI Generated SVG's

title: Show HN: AI Generated SVG's


value: waleedk

value: Show HN: Agent Farm – An IDE designed for AI and humans to work together

author: waleedk


value: brettermeier

value:
Use this CSS with eg. Stylus Firefox extension on Hackernews: Much better, ahh...<p>.spacer {
    height: 20px !important;
}
.ind {
    background: repeating-linear-gradient(
        90deg,
        #f6f6ef 0px,
        #f6f6ef 37px,
        #465298 39px,
        #465298 39px
    );
}
#hnmain {
 max-width: 1200px;
}

value: Show HN: Display of Nested Comments and Spacing

author: brettermeier


value: omersays

value: Show HN: N8n-Style Actions and AI Agents in TypeScript

author: omersays


value: ghdj

value:
I built a collection of developer tools that run entirely in the browser. No accounts, no server-side processing, no tracking.
Includes: JSON formatter/validator, CSV to JSON/SQL converter, Regex tester, Base64 encoder, Hash generator, UUID generator, JWT decoder, Cron parser, Timestamp converter, Diff checker, and more.
Tech: Plain HTML/CSS/JS. Intentionally kept it simple for fast loading and easy maintenance.
Open source: https://github.com/GhDj/dev-tools
Looking for feedback on what tools would be most useful to add next.

value: Show HN: Dev Tools – 24 browser-based utilities with no signup or tracking

author: ghdj


value: FarhadG

value:
____
Link: WebGL.com / WebGPU.com
____
Hello everyone,
This is a long time coming but I've just launched a very lean (MVP) community site for all things WebGL/WebGPU. As a long-time developer and an author in this space, I'm genuinely excited to help bring the community (i.e. creators, developers, designers, etc.) together in shaping the future of the web.
At the moment, the site's all about connecting with creators and highlighting their demos. Over the coming months, I want to add:
- News: latest and greatest info happening in this space
- Tutorials: Short-form articles and end-to-end courses teaching graphics, math, and AI/ML
- Deep Dives: Long-form interviews/posts on select demos/projects to go deeper into techniques, tools, and author
Would love to know what would make this as an experience you'd enjoy coming back to regularly.

value: Show HN: Community Site for WebGL / WebGPU

author: FarhadG


value: superstarryeyes

value:
Well, I certainly tried. I had to, because it has a certain quirk inspired by "digital minimalism."
The quirk is that it only allows you to fetch new articles once per day (or X days).
Why? Let me explain...
I want my internet content to be like a boring newspaper. You get it in the morning, and you read the whole thing while sipping your morning coffee, and then you're done! No more new information for today. No pings, no alerts, peace, quiet, zen, etc.
But with that, I needed it to be able to fetch all articles from my hundreds of feeds in one sitting. This is where Zig and curl optimisations come in. I tried to do all the tricks in the book. If I missed something, let me know!
First off, I'm using curl multi for the network layer. The cool thing is it automatically does HTTP/2 multiplexing, which means if your feeds are hosted on the same CDN it reuses the same connection. I've got it configured to handle 50 connections total with up to 6 per host, which seems to be the sweet spot before servers start getting suspicious. Also, conditional GETs. If a feed hasn't changed since last time, the server just says "Not Modified" and we bail immediately.
While curl is downloading feeds, I wouldn't want CPU just being idle so the moment curl finishes downloading a single feed, it fires a callback that immediately throws the XML into a worker thread pool for parsing. The main thread keeps managing all the network stuff while worker threads are chewing through XML in parallel. Zig's memory model is perfect for this. Each feed gets its own ArenaAllocator, which is basically a playground where you can allocate strings during parsing, then when we're done, we just nuke the entire arena in one go.
For parsing itself, I'm using libexpat because it doesn't load the entire XML into memory like a DOM parser would. This matters because some podcast feeds especially are like 10MB+ of XML. So with smart truncation we download the first few X mb's (configurable), scan backwards to find the last complete item tag, cut it there, and parse just that. Keeps memory usage sane even when feed sizes get massive.
And for the UI I just pipe everything to the system's "less" command. You get vim navigation, searching, and paging for free. Plus I'm using OSC 8 hyperlinks, so you can actually click links to open them on your browser. Zero TUI framework needed. I've also included OPML import/export and feed groups as additional features.
The result: content from hundreds of RSS feeds retrieved in matter of seconds, and peace of mind for the rest of the day.
The code is open source and MIT licensed. If you have ideas on how to make it even faster or better, comment below. Feature requests and other suggestions are also welcome, here or GitHub.

value: Show HN: I built a fast RSS reader in Zig

author: superstarryeyes


value: ralphqkly

value:
Hi HN,
I’m Ralph. I have a degree in software development, and for the past 15+ years, I’ve been doing website development and SEO, with the last 6 running an agency.
A couple of years ago, it became clear that AI could be useful in automating a lot of our agency's junior SEO tasks and manual work. I laid out our processes in detail, mapped the areas where AI could be useful, and started integrating it all.
This created an AI-powered SEO platform that automates keyword research, meta titles/descriptions, image alt text, and page-level content, with approval workflows and token-based usage. I'm also exploring automation for link building, full technical audits, and AI-generated recommended fixes.
One of the biggest struggles has been managing contextual relevance, giving the system enough information to understand a site holistically without overwhelming the model or diluting relevance.
The platform is live in beta, but I'm torn between continuing to engineer toward "perfect" versus focusing energy on sharing it earlier and letting real users guide what actually matters, so I’m here to ask for that feedback.
I’d really appreciate any insights, especially around where this would or wouldn’t fit into workflows, feedback on the quality of the responses returned, and anything that might create friction towards adoption.
To keep costs predictable during beta, users can test with a token-seeded workspace for sites of 100 pages or fewer.

value: Show HN: AI-powered SEO automation tool distilled from production agency systems

author: ralphqkly


value: kevintouati

value:
Hey HN!
I’m Kevin, the founder of HERO.
Thank you so much for checking out our launch today. We built HERO because serious work deserves better tools than paper-based documents built with word processors built in the 90s.
If your team works on contracts, policies, SOPs, technical specs, or any structured, formal documents, you know the pain:
- information buried across multiple files, sections, exhibits, etc.
- repeated copy-pasting
- outdated definitions
- impossible cross-referencing
- version chaos
- hours wasted searching for the right clause, number, term, or page
HERO solves this by combining the flexibility of text, the structure of a database, and the power of live integrations, all inside one collaborative workspace.
Everything becomes interconnected: sections → definitions → clauses → data variables → linked documents → live values .. And the search is instant, whether you have 10 or 10,000 documents.
With HERO, you save ~2 hours per day (every day):
- No more digging for past clauses
- No more re-entering data in multiple documents
- No more checking if a definition was updated in all files
- No more manually coordinating versions
- No more rewriting work that already exists somewhere else
- No more switching between Word, PDFs, spreadsheets, emails, and shared drives just to complete one task
When all your structured documents share the same definitions, data, and references and they update everywhere automatically, the time savings compound fast.
If you work in legal, operations, compliance, engineering, or any document-heavy field, HERO gives your team back 10 hours a week you’re currently losing to admin and document chasing.
This came from years of professional experience as a corporate lawyer. We’ve poured a lot of heart, honesty, and hard lessons into building this.
We also recently made to the top #3 product of the day on Product Hunt on a particularly competitive day.
Would love your feedback, questions, or just to hear how your team currently handles this kind of work.
Thanks for being here, it means a lot.
Kevin

value: Show HN: HERO – Notion for Formal Docs

author: kevintouati

title: Show HN: HERO – Notion for Formal Docs


value: misterchocolat

value:
Alright so if you run a self-hosted blog, you've probably noticed AI companies scraping it for training data. And not just a little (RIP to your server bill).
There isn't much you can do about it without cloudflare. These companies ignore robots.txt, and you're competing with teams with more resources than you. It's you vs the MJs of programming, you're not going to win.
But there is a solution. Now I'm not going to say it's a great solution...but a solution is a solution. If your website contains content that will trigger their scraper's safeguards, it will get dropped from their data pipelines.
So here's what fuzzycanary does: it injects hundreds of invisible links to porn websites in your HTML. The links are hidden from users but present in the DOM so that scrapers can ingest them and say "nope we won't scrape there again in the future".
The problem with that approach is that it will absolutely nuke your website's SEO. So fuzzycanary also checks user agents and won't show the links to legitimate search engines, so Google and Bing won't see them.
One caveat: if you're using a static site generator it will bake the links into your HTML for everyone, including googlebot. Does anyone have a work-around for this that doesn't involve using a proxy?
Please try it out! Setup is one component or one import.
(And don't tell me it's a terrible idea because I already know it is)
package: https://www.npmjs.com/package/@fuzzycanary/core
gh: https://github.com/vivienhenz24/fuzzy-canary

value: Show HN: Stop AI scrapers from hammering your self-hosted blog (using porn)

author: misterchocolat


value: adamoufkir

value:
Hey HN! Adam here. I’m a developer and founder, and I’ve shipped a lot of landing pages that looked fine but didn’t convert. The frustrating part wasn’t low conversion itself, but not knowing what exactly was wrong or what to test next without traffic data or paid CRO audits.
I built Crovise, a system that analyzes a landing page and outputs concrete conversion hypotheses. It reviews structure, copy, hierarchy, and UX patterns using static analysis combined with heuristics and LLM-based reasoning.
The goal isn’t to replace analytics or A/B testing, but to give a fast, opinionated pass similar to how a CRO engineer would review a page early on. There’s no session data or tracking involved yet, so all feedback is based on page content and layout.
I unlocked access for Show HN users so you can try it without signing up. I’m especially interested in feedback on the approach, blind spots, and cases where this kind of analysis breaks down.

value: Show HN: We built Crovise to understand why landing pages don't convert

author: adamoufkir


value:
I built a small Linux tool to deterministically verify GPU PCIe link health and bandwidth.
It reports:
- Negotiated PCIe generation and width
- Peak Host→Device and Device→Host memcpy bandwidth
- Sustained PCIe TX/RX utilization via NVML
- A rule-based verdict derived from observable hardware data only
This exists because PCIe issues (Gen downgrades, reduced lane width, risers, bifurcation) are often invisible at the application layer and can’t be fixed by kernel tuning or async overlap.
Linux-only: it relies on sysfs and PCIe AER exposure that Windows does not provide.

value: Show HN: Deterministic PCIe Diagnostics for GPUs on Linux


value: brandonin

value:
Hey HN! I am the founder at a24z.
I have been doing software development for over a decade in healthcare, education, and non-profits.
I recently started a24z after talking to over 200 engineering leaders about their largest pain points.
It originally started off as an Observability tool so that engineering leaders can see adoption, ROI, etc. for their engineering organizations, but as teams started to evolve with the way they utilize AI Coding tools, so did the platform I was building.
We are now looking at features that do security scanning, autonomously upgrading your Claude Code with Skills, Plugins, and guardrails to help optimize engineering teams.
Think of us as an in-house Platform Engineer.

value: Show HN: A24z – AI Engineering Ops Platform

author: brandonin


value: Jahboukie

value:
Rust's Deterministic Advantage
SecuraMem is the AI Black Box Recorder that provides court-admissible cryptographic proof of every AI decision. Our NeuroWall semantic firewall blocks 90-100% of jailbreak attempts before they reach your LLM. Deploy in minutes with a 100MB single binary—no cloud, no dependencies.
https://youtu.be/8RjfMskvC_4

value: Show HN: 100MB Rust Binary- AI Auditability Substrate

author: Jahboukie


value:
Hi HN,
I built semantic-relevance while trying to solve a problem I kept running into with my own feeds.
I follow Hacker News, GitHub Trending, Reddit, Lobsters, and a few RSS feeds. Even though the content is high quality, most of it is still noise for my current context. Popularity does not equal relevance, and the same items keep resurfacing because they are always trending.
This library treats signal as the intersection of three things:
Relevance: semantic similarity to a user-defined context
Novelty: decay-based tracking so repeat items fade over time
Classification: lightweight labels explaining why something surfaced
It is intentionally a small, embeddable primitive, not a feed reader or a recommender system. You give it items plus a markdown description of what you care about, and it returns scored “signals.”
Under the hood it uses:
Local embeddings (MiniLM via @xenova/transformers, no APIs)
Cosine similarity
Simple decay math for novelty
Explainable scoring instead of learned ranking
I’m using it as a building block inside a larger project, but the library itself is standalone and reusable.

value: Show HN: Semantic-relevance, finding signal in noisy feeds


value:
Hey,
This is my first time here, but I really need good reviews and insights from professionals and people.
I built Ghost because I have a bad habit: I write code first, tell myself I’ll write the tests later, and then never do because setting up mocks and imports breaks my flow state.
I wanted a tool that acts less like a chatbot and more like a background daemon that handles the grunt work.
What it does:
Ghost watches your file system. When you save a .py file, it:
Scans Context: Instead of dumping raw files, it uses Python’s ast module to map functions and classes to minimize token usage.
Generates: Writes a pytest suite using your local LLM (Ollama) or Groq.
Executes & Heals: Runs the test in a subprocess. If it fails (e.g., ModuleNotFoundError or syntax errors), it captures the stderr, feeds it back to the model, and patches the file automatically.
The "Judge" Problem:
A big issue with AI testing tools is that they often modify tests to match buggy code ("testing the implementation"). I added a "Judge" step: if a test fails due to a logic error (AssertionError), a separate prompt analyzes whether the source code is buggy or the test is wrong. If the code is buggy, it halts and alerts you rather than fixing the test to pass.
Stack:
Python (Watchdog, Rich)
LLM Support: Ollama (Local), Groq (Fast), OpenAI.
License: MIT
It’s definitely still in beta, but the self-healing loop is working well for my side projects. I’d love feedback on the AST context injection strategy or the self-healing logic.
Repo: https://github.com/tripathiji1312/ghost
Pip: pip install ghosttest

value: Show HN: Ghost – Local-first agent that runs and auto-fixes Python tests


value: faalantir

value: Show HN: Cwhy – Explain and fix terminal errors using AI (written in Go)

author: faalantir


value: hodak

value: Show HN: Hotpath-rs – Real-time Rust performance, memory and data flow profiler

author: hodak


value: realsharkymark

value:
Hi HN,
I’m from the team at Nuon. While building in the Bring Your Own Cloud (BYOC) space, we realized there wasn't a centralized, community-driven resource like awesome-selfhosted.net for managed software that lives in the customer's VPC.
We hope software vendors will open a PR and add their BYOC offerings.

value: Show HN: A community-curated list of BYOC (Bring Your Own Cloud) vendors

author: realsharkymark


value: neuraldenis

value: Show HN: Test Chrome's Built-In Prompt API

author: neuraldenis


value: MMAFRAZ

value:
I built Vect because I was tired of "Random Acts of Marketing" and juggling 15 disjointed tools (LLMs for text, separate image gens, spreadsheets for planning). I wanted a cohesive system—an OS—rather than just a wrapper.
Refusing to be another "text generator," we built Vect on three architectural pillars:
Strategy (The Brain): Agents that research/plan using live web search and user psychology simulations.
Execution (The Hands): Native integration of high-fidelity models (Veo for video, Imagen for images) to do the actual work.
Automation (The Workforce): A "State-Aware" agent system. Through a persistent "Brand Profile," all agents share memory of your tone, audience, and product—eliminating the need to re-prompt context.
The goal is to move from "Idea" to "Executed Campaign" in minutes by having agents do the heavy lifting in the background.
We wrote a full guide on the architecture and credit economy here: https://blog.vect.pro/vect-ai-bible-guide
Would love feedback on the agent orchestration approach!

value: Show HN: Vect – An Operating System for Autonomous Marketing Agents

author: MMAFRAZ


value: TheMirskyLimit

value: Show HN: The Mirsky Ratio–Measuring R&D vs. SG&A as a predictor of S&P 100

author: TheMirskyLimit


value: RaulOnRails

value: Show HN: Calm Companies – Businesses where less is more

author: RaulOnRails


value: jonnotdoe

value:
Hi HN, I have been working on this AI agent that teaches calculus by drawing on a whiteboard in realtime. Because it is in realtime, You can ask questions mid lesson and the lesson will adapt.
I'd love your feedback on usability, and whether it is actually useful.
You can try it out here: useboardspace.com
with this demo account since the tool is not live yet
demo account: "demotest@useboardspace.com" \ "emilio-plate-grit-breather". [demo account will be deleted once credit runs out]
Thank you

value: Show HN: BoardSpace – AI that draws on a whiteboard in realtime for Calculus

author: jonnotdoe