value: Fileformat

value:
One of the things hindering RSS/Atom is poor discoverability.
Normally, clicking on a link to an RSS/Atom feed brings up either a "wall of text" or even worse, a "Save As" dialog, both of which are useless and especially hostile to newcomers. This has lead to authors avoiding putting visible links to their feeds in their HTML pages.  So now newcomers never even learn that feeds exist, never mind learn how useful they are!
I (with your help) can do something to get rid of the wall of text: make your feeds display as HTML when you click on them, even though the content is still valid XML!
So take a look at RSS.Style [1] and use the scripts to make your RSS/Atom feeds presentable.  You can hotlink the scripts or use them as a starting point for your own feed styling.  Code is pretty straightforward and easy to hack.
The other thing that I discovered while working on RSS.Style is that people are not paying enough attention to their feeds.  RSS.Style requires that the basic fields are present (and correct) so it can use them in the template: It is shocking how many high-profile bloggers have errors in their feeds.  I made a Feed Analyzer[2] that points out some common mistakes that are not covered by the W3C's feed validator.  I name and shame some of the top HN contributors[3] on the RSS.Style home page.  Even HN's feeds have issues [4] !  (<- @dang take note!)
I originally wrote RSS.Style using XSLT, but Google, as the malevolent friend of the open web, is deprecating XSLT.  So I switched to JavaScript, which works everywhere as long as you use a supported Content-Type.
Source is available[5] and everything is MIT licensed.  The preview and analyzer are written in TypeScript (no judging! it is just a side project!) and hosted on Cloudflare Pages.
[1] https://www.rss.style/
[2] https://www.rss.style/feed-analyzer.html
[3] https://www.rss.style/#examples
[4] https://www.rss.style/feed-analyzer.html?feedurl=https%3A%2F...
[5] https://github.com/fileformat/rss.style

value: Show HN: RSS.Style – better UX for RSS/Atom links, now using JS instead of XSLT

author: Fileformat


value:
I kept making watchlists but rarely watching anything and I spent more time browsing than watching. After stepping away from streaming services for a bit, I realized I missed having a TV schedule.
So, I built this to help me decide what I’m watching ahead of time by auto-scheduling episodes or movies into time slots. So far, it’s worked better than a watchlist. I actually look forward to watching things now.
This is a working but early version. I’d love feedback on the UX/UI, how easy it is to use, any criticism, and whether this approach holds up for other people.
NOTE: It is free to use for 7 days and there are no ads.
Link: https://app.showshowshow.app

value: Show HN: I built an auto-scheduler to help me decide what I'm watching


value: Show HN: Zelda like dungeon clone written in Phaser and TypeScript


value:
I just released an open-source tool called *Grafana Alerts Dashboard*, and I thought some of you might find it useful altough it might be a bit niche.
Grafana’s built-in alerting works well, but once you have multiple folders, datasources, or environments, it gets surprisingly hard to answer simple questions like:
- Which alerts are currently firing?
- Which ones are disabled or silenced?
- Direct link between silenced alerts and their contact points?
This project provides a *dedicated dashboard that aggregates and visualizes Grafana alerts* in one place.
## What it does
- Simplified alert UI for Walldisplay or TV screens
- Shows all alert rules across folders and datasources and multiple Granafana instances
- Clear status overview (firing, pending, normal, disabled)
- Highlights alerts visually and audibly when they fire
- Simple Search and filter views
## What it is not
- It’s not a replacement for Grafana’s built-in alerting or notification system
- It doesn’t manage or change alert rules, just visualizes them
- It does not write to your Grafana instance or modify any settings
## Why I built it
In my own self-hosted Grafana setup, alerting grew organically and eventually became messy, specially when handling multiple Grafana instances. I wanted a *single pane of glass* just for alert hygiene and visibility—something Grafana doesn’t really provide out of the box.
## Repository
 https://github.com/mms-gianni/grafana-alerts-dashboard
Feedback, issues, and PRs are very welcome.
Happy to answer questions or explain design decisions if anyone’s curious.
If you’re running Grafana at home or in a homelab and care about alert quality, I think this will save you some time

value: Show HN: I built an open source Grafana Alerts Dashboard


value: kiyo-e

value:
Hi HN — I built Pairlane, a WebRTC-based P2P file sharing tool.
Core idea: file bytes never pass through the server. The server only does WebSocket signaling (Cloudflare Workers + Durable Objects), while the actual transfer happens peer-to-peer over a WebRTC DataChannel.
It works for:
- browser ↔ browser
- browser ↔ terminal
- terminal ↔ terminal (via an npx CLI wrapper)
CLI quick start:
- npx pairlane send /path/to/file
- npx pairlane receive <ROOM_ID_OR_URL> --output-dir ./downloads
Security:
- Optional E2E encryption (AES-GCM). The key lives in the URL fragment (#k=...) and is never sent to the server.
Demo: https://getpairlane.com/
Repo: https://github.com/kiyo-e/pairlane
Notes:
- No TURN by default (STUN-only), so some strict NAT/corporate networks may fail.
- Very large files can hit browser memory constraints depending on the environment/implementation.

value: Show HN: Pairlane – P2P file sharing, no file bytes on server (WebRTC)

author: kiyo-e


value: AI-powered image upscaler for anime, manga, and photos. Drop your PNG, JPG, or WebP file, upscale to 2x, 4x, or 8x with noise reduction and face enhancement. Free credits on signup.

value: Show HN: Waifu2x Online – Browser-based anime image upscaler (2x/4x/8x)


value: lloydjones

value:
What it is:
PEC (Protocol-Embedded Compliance) is an academic proposal to extend Model Context Protocol (MCP) with compliance metadata, so AI agents can make compliance-aware tool selections.
The problem:
When an AI agent discovers tools via MCP, it has no standard way to know where that tool processes data, what certifications it holds, or what use restrictions apply. Each deployer has to figure this out manually.
The proposal:
A JSON schema extension where MCP servers declare processing locations (e.g., "EU-only", specific countries), certifications (HIPAA, PCI-DSS, ISO 27001, etc.), and use restrictions.
This lets compliance-aware orchestrators filter tools before invocation.
Current status:
Draft paper targeting Q1 2026 publication. Draft schema available at https://usepec.eu. No adoption yet — seeking feedback from the MCP ecosystem.
What it's not:
This doesn't guarantee compliance or replace legal review. It standardises how tools declare compliance characteristics. The bet is that protocol-level standardisation is worth the coordination cost.
Happy to discuss the technical approach, alternative designs, or why this might be a terrible idea.

value: Show HN: PEC – A proposal for compliance metadata in the Model Context Protocol

author: lloydjones


value: alexsherrick

value:
I wanted old school social media back. Actual connections with friends. Not pity likes and performances and highlight reels.
All my friends have stopped posting. Everyone's a lurker now. I'm a lurker. The only time I see what anyone's doing is when it's a humblebrag. I have no idea what's actually going on in my friends' lives besides the ones I see every week or so.
So I built touch grass. You post once a week: 3 easy questions, max 3 photos. Sunday 6pm mountain time (yeah its my time zone) everyone's posts unlock at the same time. You catch up on what your people have been doing, then close the app. No likes, no comments, no algorithm, no advertisers, no bullshit, besides that one friend maybe.
It's not about content. It's about keeping the connection warm. I see my friend went to the Cowboys game (Texans represent), I text him and ask how it was. That's it. That's the whole point. A reason to actually reach out.
I've weirdly learned more about my parents in the last 5 weeks than the last year it feels like. I get real answers, not performances. It's honestly my favorite thing right now but I built it so I guess that means I'm biased.
When someone asks me "what'd you do this week?", usually I have no idea or at least it takes me a little while. But when I sit down to post, I actually think about it. And my friends see the real stuff, not a curated highlight reel.
The tech:
I'm a solo dev. I wanted this to actually survive for years, not die when I couldn't afford the AWS bill. So I needed it cheap. Really cheap. That's when I thought about old school social media. We were using terrible flip phones and marginally good digital cameras, but everyone wanted to be tagged in their photos on Facebook. So I thought using a polaroid filter would be a great way to save some money. Everyone looks good in a polaroid, the warm tones, the grain, the vignette. People steal them from my house, those bastards. It plays into the old school social media vibe perfectly. But here's the thing: it also gave me permission to compress the hell out of every image. 600px, 70% quality, webp. Each photo comes out to sub 40kb, sometimes as little as 10kb, instead of 2mb. The aesthetic hides the compression, but honestly everyone just thinks it works. From the limited data I've gotten.
The whole thing runs on Cloudflare Workers + D1 + R2. Cloudflare is legit the best thing on this planet in my opinion. It's about $5/month for the paid workers but the key is R2 egress, it's also free. Every time someone loads a photo, I pay nothing. On AWS that would be $0.09/GB and I'd be dead. At 10k users loading feeds every Sunday, that's the difference between $0 and $50+/month just in bandwidth. At 100k or 1MM it would start to be too much but on Cloudflare it's quite affordable.
I can run a photo-sharing social network for the cost of a beer or maybe 3 overpriced donuts. That's the only reason this is possible without funding.
I literally just launched a couple of weeks ago with a couple of friends and now I'm at ~150 users right now. I honestly have no idea where some of these users are coming from, that part has been pretty fun. The new year felt like the right time to share, everyone's thinking about screen time and staying connected. This is hopefully my answer to both.
Its free, there's no ads, and I don't sell any data. Honestly who would be buying it. I would love to hear any feedback. It is not perfect by any means but its the most polished thing I've built for the web.
Thanks for reading.
screenshots: https://trytotouchgrass.com/hn
mainpage: https://trytotouchgrass.com

value: Show HN: Touch grass – I built social media that wants you to close it

author: alexsherrick


value: itake

value:
Inspired by a "What are you working on" post, I created a version that is purely local:
https://news.ycombinator.com/item?id=46579317
The quality isn't amazing with the gemma3:12b model, but it does its job.

value: Show HN: Local Screenshot Image Rename

author: itake

title: Show HN: Local Screenshot Image Rename


value: jxywilliams

value:
Hey HN,
A while back I realized I was spending hours every week just repurposing content from platform to platform. I needed that time back.
So I built Nebly, a tool for you to repurpose Youtube videos, podcast transcripts or key insights into content for major platforms.
Personalized content, understands you and your industry, written content funnel sorted!
Jay

value: Show HN: I built a tool to repurpose long form content into my short form funnel

author: jxywilliams


value: binalpatel

value:
Fun agent I've been playing with - the idea is it only has access to a bash tool, and it's directed to create CLIs for use (with additional direction to make the CLIs composable, follow the Unix philosophy, etc).
It persists these CLIs and knowledge about them get injected into the system prompt dynamically, so each time it runs it gets access to a larger and larger toolset of composable CLIs.
One interesting dynamic that's emerged from this is I've started using these CLIs myself since they're the same interface for the agent or for me, and it's turned into kind of non-chat channel to interact with the agent.
One example - I'll add tasks throughout the day myself using the `tasks` CLI it made, then when I interact with the agent it'll run `tasks list` and see everything I've added, or use it to prioritize/update things for me. Later on when I run `tasks list` myself I see all the updates/priorities it set.

value: Show HN: LLM Agent That Makes Composable CLIs

author: binalpatel


value:
I’m building Verdic Guard, an experiment around a problem I kept running into while working with LLMs in production.
LLMs usually behave well in demos and short interactions, but once they’re embedded into long, multi-step or agentic workflows, they can drift in subtle ways. Prompt tuning, retries, and monitoring help, but they don’t clearly define or enforce what the system is actually allowed to do.
Verdic Guard explores a different approach: treating AI reliability as a validation and enforcement problem, not just a prompting problem. The idea is to define intent, boundaries, and constraints upfront, and then validate outputs against those constraints before they reach users or downstream systems.
This is still early and opinionated. I’m sharing it to get feedback from people who’ve dealt with:
LLMs in long-running workflows
Agentic systems that accumulate context
The gap between “it worked in testing” and “it’s safe in production”
I’d especially love to hear where this framing breaks down, or if you’ve seen better ways to think about output reliability.
Project: https://www.verdic.dev
Happy to answer questions or learn from critiques

value: Show HN: Verdic Guard – validating LLM outputs against intent, not just prompts


value: markushirsimaki

value:
Author here.
I started seapie as a reaction to pdb's command-driven interface in 2019. I wanted a breakpoint to simply mean 'open a Python REPL here', with debugging functionality layered on top instead of replacing the REPL.
`seapie.breakpoint()` opens a working `>>>` REPL at the current execution state. Any changes to variables or function definitions persist. Debugger state is exposed via built-ins (e.g. `_magic_`), and stepping/frame control/etc is handled via small `!commands`.
I've been using this regularly in my own work for a few years now. Happy to answer questions or hear criticism, especially from people who've used debuggers heavily.

value: Show HN: Seapie – a Python debugger where breakpoints drop into a REPL

author: markushirsimaki


value: messh

value:
I built a service that gives you instant Linux boxes using only SSH. No accounts, no CLI tools, no browser – just:

  ssh shellbox.dev

Your SSH key is your identity. First connection creates your account.
Commands work over SSH:
  ssh shellbox.dev create mybox
  ssh -t shellbox.dev connect mybox
  ssh shellbox.dev list
Each box gets a public HTTPS URL for serving apps or webhooks.
Pricing: $0.05/hr running, $0.005/hr paused. Boxes auto-pause on disconnect and resume where you left off.
Even billing stays in the terminal – run `ssh shellbox.dev funds 10` and you get a QR code right in your shell. Scan it, pay via Paddle, done. No account dashboards.
Specs: 2 vCPUs, 4GB RAM, 50GB SSD per box.
I wanted something I could spin up from any machine with just a terminal. No installs, no OAuth flows, no "please verify your email." Works great for quick experiments, running Claude Code in isolation, or giving demos a public URL.
Would love feedback. What's missing?

value: Show HN: Shellbox – Instant Linux Boxes via SSH

author: messh


value: crog

value:
I'm a non-technical guy who spent 2 months trying to ship software with AI tools. Not toy projects — real things I wanted to use. Finance analyzers, productivity tools, dev utilities.
The models are incredible. But the loop was broken.
Every session started from zero. Context would explode. The AI would hallucinate with confidence. And because I can't read code, I had no way to verify when something was wrong. I just knew it was broken.
So I stopped fighting the model and started building the system around it.
Pilot is a /pilot folder you drop into any repo. It's emergent complexity from simple primitives — markdown files that give AI tools:
Persistent state (STATE.md tracks where you are in the workflow)
Scoped tasks (TASK.md defines boundaries before implementation)
Evidence capture (real terminal output via MCP, not generated text)
Protected paths (red zones require human approval)
Recovery (LKG commit auto-updated after health passes)
The core insight: split the AI into two roles.
Orchestrator (Claude/ChatGPT) — high reasoning, low volume. Writes specs, reviews evidence, manages flow.
Builder (Cursor/Claude Code) — high volume, lower cost. Implements, provides proof.
The Orchestrator defines scope before the Builder touches anything. The Builder works within boundaries. The Orchestrator reviews after. Two models, two verification passes.
It's moving from "trust me" to "show me the terminal."
Why I needed this:
I wanted to program by intuition, not by syntax. I can design systems. I can spec features. I can verify that tests pass and URLs work. What I can't do is read 200 lines of generated TypeScript and know if it's correct.
So the system had to prove correctness without requiring code review. Evidence-based commits. Scope contracts. Clear rejection criteria.
It's shared intuition for messy realities. Not a sandbox — I know markdown isn't a firewall. It's defense in depth: separation of concerns, multi-model review, explicit rules, human gates.
Technical notes:
The workflow is a state machine: idle → building → verifying → done. Evidence comes from MCP-captured terminal output. The Orchestrator validates Builder output against TASK.md constraints. Red zone violations trigger automatic escalation.
The /pilot folder is just markdown. Any MCP-enabled tool can read it. No vendor lock-in.
Limitations (being honest):
Solo builder workflow. Team use needs merge strategy for state files.
Convention-based, not filesystem-enforced. If you need true isolation, run in a container.
Context can still drift if you skip the workflow. Health checks help, but it's not foolproof.
Token overhead exists. Trading cost for correctness insurance.
What I've built with it:
Private projects mostly — finance analyzer, productivity tools, Framer components, and Pilot itself. Iterating on the workflow every time I hit a wall until the walls stopped appearing.
Now using it on bigger things I plan to release.
Felt too good not to share.
Happy to discuss the architecture, failure modes, or specific edge cases.

value: Show HN : Pilot – System to improve dramatically your AI coding

author: crog


value: Poc

value:
Hi HN,
I came up with a simple web app to take digital notes from physical books. The goal is to remove the friction between reading on paper and a well-formatted Markdown file.
It uses Whisper to record voice notes that are then parsed by an LLM. The notes are saved in a database and can be exported from computer or phone into Markdown (for Obsidian) or CSV (for Notion).
It is very early days (v0.1.0). Right now, it purely captures the notes; there is no search or fancy organisation yet. I just wanted to solve the capture problem first.
It is built with Python, Streamlit, and Supabase.
You can try it here: https://marginal-ia.com/ (might reach rate limits!)
Cheers.

value: Show HN: Marginal IA – An open source Readwise for physical books

author: Poc


value: Yreminder

value: Show HN: Remove Gemini Watermarks – Client-Side Processing, No Upload Required

author: Yreminder


value: taklaxbr

value: Show HN: Zai Protocol – I designed an autonomous P2P terminal agent (Whitepaper) [pdf]

author: taklaxbr


value: jcoulaud

value: Show HN: A marketplace for vibe coded projects

author: jcoulaud


value: illhangon

value: Show HN: DogEar – A tool for book retention via environmental priming

author: illhangon


value: yunjywork

value: Show HN: Wirey – Socket testing client with JavaScript scripting

author: yunjywork


value: JosefAlbers

value: Show HN: VL-JEPA(Joint Embedding Predictive Architecture for Vision-Language) [video]

author: JosefAlbers


value:
Author of the "Confident Idiot" post here (https://news.ycombinator.com/item?id=46152838).
After that discussion, I looked at my own agent code and realized it was 80% error handling and 20% reasoning. I was manually decorating every function with retries, regex checks, and JSON validators. It was unreadable.
I realized that reliability shouldn't be Application Code; it should be Infrastructure.
I built Steer to test a pattern: Monkeypatching the framework to decouple reliability.
Instead of decorating functions, I initialize Steer at the entry point. It hooks into the framework's lifecycle (PydanticAI / OpenAI), introspects the tools, and attaches "Reality Locks" (SQL parsers, Schema checks, Entropy filters) globally.
Before (The Spaghetti):

  # Business logic mixed with safety logic
  @retry(stop=stop_after_attempt(3))
  def run_query(q):
      if "DROP" in q: raise Error() # Manual check
      response = agent.run(q)
      if not is_valid_sql(response): raise Error() # Manual check
      return response

After (The Mesh):

  import steer
  # One line patches the framework globally.
  # Auto-attaches SQL validators to any tool returning SQL.
  steer.init(patch=["pydantic_ai"], policy="strict_sql")

  # Pure Business Logic
  agent.run(query)

It currently handles SQL AST validation, PII redaction, and a "Slop Filter" (using Shannon Entropy to block apologies).
It’s open source and local-first. I’m curious if anyone else is using this "sidecar" pattern or if you prefer explicit middleware?
Repo: https://github.com/imtt-dev/steer

value: Show HN: I got tired of "Reliability Spaghetti," so I monkeypatched PydanticAI


value: sestarkman

value: Show HN: I built Lexica, a bot that texts you a Word-of-the-Day every morning

author: sestarkman


value: thenodeshift

value: I built a unit conversion site that has the support for 30 languages. the intent to make this the best in it's class. I'll be expanding this to  include all the categories and support more languages in the future.<p>lightweight, mobiles friendly. light/ dark themes with the best features possible!

value: Show HN: Will be the best unit conversion site on the planet

author: thenodeshift


value:
I built a small Python library to improve WebSocket connection stability in FastAPI apps.
fastapi-websocket-stabilizer wraps FastAPI’s native WebSocket with automatic heartbeat (ping/pong) handling to reduce unexpected disconnects caused by idle timeouts or unstable networks. It’s lightweight, easy to integrate, and focused only on keeping long-lived WebSocket connections reliable—no full real-time framework, no extra abstractions.
I built this after repeatedly reimplementing keepalive logic across multiple FastAPI projects. The goal is to encapsulate that logic in a minimal, reusable way. Removal is straightforward if you decide not to use it later.
GitHub: https://github.com/yuuichieguchi/fastapi-websocket-stabilize...
PyPI: https://pypi.org/project/fastapi-websocket-stabilizer/
Feedback welcome, especially from people running WebSocket-heavy FastAPI services.

value: Show HN: A minimal wrapper for stable FastAPI WebSockets


value: yathern

value: Hi HN! This is a word search game I launched in the beginning of this year - didn't get much traction then, but it's been posted around a bit (right now getting some traffic from kottke.org) and now has over 12,000 words found!<p>Now that it's a little more filled out I figured I'd share it again. Really enjoying seeing what everyone is making on it - it appears most people start by just adding a few words to the big clump in the middle, then adding to other people's projects (or ruining them) and finally working on their own little concepts. My favorite is the kitty to the north. Hope you enjoy!

value: Show HN: words.zip – Massively infinite word search

author: yathern


value:
Hi! I’m Nathan: an ML Engineer at Mozilla.ai: I built agent-of-empires (aoe): a CLI application to help you manage all of your running Claude Code/Opencode sessions and know when they are waiting for you.
- Written in rust and relies on tmux for security and reliability
- Monitors state of cli sessions to tell you when an agent is running vs idle vs waiting for your input
- Manage sessions by naming them, grouping them, configuring profiles for various settings
I'm passionate about getting self-hosted open-weight LLMs to be valid options to compete with proprietary closed models. One roadblock for me is that although tools like opencode allow you to connect to Local LLMs (Ollama, lm studio, etc), they generally run muuuuuch slower than models hosted by Anthropic and OpenAI. I would start a coding agent on a task, but then while I was sitting waiting for that task to complete, I would start opening new terminal windows to start multitasking. Pretty soon, I was spending a lot of time toggling between terminal windows to see which one needed me: like help in adding a clarification, approving a new command, or giving it a new task.
That’s why I build agent-of-empires (“aoe”). With aoe, I can launch a bunch of opencode and Claude Code sessions and quickly see their status or toggle between them, which helps me avoid having a lot of terminal windows open, or having to manually attach and detach from tmux sessions myself. It’s helping me give local LLMs a fair try, because them being slower is now much less of a bottleneck.
You can give it an install with
curl -fsSL https://raw.githubusercontent.com/njbrake/agent-of-empires/m...  | bash
Or brew install njbrake/aoe/aoe
And then launch by simply entering the command `aoe`.
I’m interested in what you think as well as what features you think would be useful to add!
I am planning to add some further features around sandboxing (with docker) as well as support for intuitive git worktrees and am curious if there are any opinions about what should or shouldn’t be in it.
I decided against MCP management or generic terminal usage, to help keep the tool focused on parts of agentic coding that I haven’t found a usable solution for.
I hit the character limit on this post which prevented me from including a view of the output, but the readme on the github link has a screenshot showing what it looks like.
Thanks!

value: Show HN: Agent-of-empires: OpenCode and Claude Code session manager


value: mullion

value:
Hi HN — I built Mullion, an OSS TS toolkit to prevent LLM context leaks (admin/user, internal/external boundaries).
- Owned<T, Scope> tags data with trust scope
- scope crossing requires explicit bridge(...)
- ESLint rules flag cross-scope use / leaked values
- OpenTelemetry-compatible tracing + cost estimation
integrates with Vercel AI SDK
npm i @mullion/core @mullion/ai-sdk
https://github.com/mullionlabs/mullion-ts
Feedback welcome: does this model match how you handle trust boundaries in production?

value: Show HN: Mullion – type-safe LLM context management for TypeScript

author: mullion


value:
Gitmore (https://gitmore.io) – dev visibility from metadata only.
Most analytics tools want to clone your repos or request full read access. We don't.
Gitmore uses webhooks. When you connect a repo, the Git platform pushes event data to us. We never pull.
*What we receive:*
- Commit messages
- PR titles and descriptions
- Timestamps
- Author info
- File counts
*What we never see:*
- Source code
- Diffs
- File contents
- Secrets
*What you can do with metadata:*
Ask questions:
- "What shipped last week?"
- "Which PRs are stuck?"
- "Who's working on the billing service?"
Schedule reports:
- Weekly or monthly summaries
- Delivered to Slack or email
- Forward to investors or stakeholders
Other features:
- Slack bot for team-wide access
- Public changelog at yourcompany.gitmore.io/changelog
- Contributor leaderboard
*How we structure the data:*
Every event gets normalized into a standard schema. The AI queries structured data, not raw commit messages. PR descriptions carry more context than commits – we capture both.
*Stack:*
Next.js, MongoDB, Claude
- Token encryption: Fernet (HMAC-SHA256 + AES-128-CBC)
- Webhook verification: Timing-safe HMAC-SHA256
- 2FA: TOTP + backup codes
Works with GitHub, GitLab, and Bitbucket.
Free for 1 repo: https://gitmore.io
Would you trade code-level analytics for better security?

value: Show HN: Dev visibility for founders who don't code


value: samarthahathwar

value:
I built a system to solve the biggest problem with AI-assisted coding: you can't maintain the code 6 months later because you've lost all context about WHY it was written.
The core idea is simple: instead of jumping straight into code, you generate specifications first, then track every planning decision and todo in markdown files that move through folders (plans → in-progress → executed). This execution history stays with your project forever.
The toolkit includes:
- Spec generators (architect + development specs from requirements)
- Session management (track progress across coding sessions)
- Execution history tracking (the 3-folder system)
- Git workflow helpers (branches, conventional commits)
- Spring Boot test generation
- Automated code review agents (OWASP security, SOLID, performance)
It's built for Claude Code but the workflow concepts apply to any AI coding tool.
I used this to build a complete Spring Boot backend — 45-day estimate compressed to 5 days. The execution history is still readable months later.
$49 for the complete toolkit: https://hathwar.gumroad.com/l/spec-driven-ai
Landing page with full details: https://samhath03.github.io/spec-driven-ai/
Happy to answer questions about the workflow.

value: Show HN: Spec-Driven AI Development – Keep AI-Generated Code Maintainable

author: samarthahathwar


value:
I’m building Verdic Guard to explore a problem I kept seeing with LLMs in production.
Models often behave well in demos and short interactions, but once they’re embedded into long, agentic, or real-world workflows, outputs can drift in subtle ways. Prompt tuning, retries, and monitoring help, but they don’t clearly define or enforce what the system is actually allowed to do.
Verdic Guard treats AI reliability as a validation and enforcement problem, not just a prompting problem. The idea is to define intent, boundaries, and constraints upfront, then validate outputs against those constraints before they reach users or downstream systems.
This is early and opinionated. I’m sharing to get feedback from people who’ve dealt with:
LLMs in long-running or agentic workflows
Production reliability vs demo behavior
Guardrails beyond prompt engineering
Project: https://www.verdic.dev
Happy to answer questions or hear critiques.
— Kundan

value: Show HN: Verdic Guard – deterministic guardrails for production AI


value: Ismach

value: Show HN: Chronos-Track – Detect honeypots via TCP timestamp clock skew (Rust)

author: Ismach


value: spider-hand

value:
Hi HN,
I built and just released another Geoguessr alternative. The difference from most other games (and the official one) is that it doesn't use Google Maps APIs at all, which makes the game more sustainable while keeping the service free.
This is the successor project to a Geoguessr-like game I built a long time ago. I've been learning since then and felt I could design and implement the project in a cleaner way this time. That motivation led me to rebuild it from scratch.
If you’re a light user who’s hesitant about paying for a subscription and looking for an alternative, feel free to give it a try. I’d really appreciate any feedback.
Source code: https://github.com/spider-hand/geoguess-lite

value: Show HN: Geoguess Lite – open-source, subscription free GeoGuessr alternative

author: spider-hand


value: AndreiBargan

value:
Install our Reality Check Chrome extension and you'll be able to:
- like/dislike any posts on major platforms, especially on X :) Likes are synced with the platform’s own ones.
- rate and comment on any site. It's like TrustPilot, but always there.
- become a reviewer/fact-checker and report fake news, AI-slop, scams, etc. on any post, so that users can see your short review right on this post — with a link to your site/channel for more details, giving you traffic. It’s like Community Notes on X, but better :)
- check authors’ credibility based on how many fakes or misleading posts they’ve published.
- comment even if the author has blocked comments on the post.
- later we’ll promote expert opinions in our comments so they don't drown in low-quality or toxic discussions.
This solves the problem of social networks being toxic and misleading, with tons of AI-slop and inflated social influencers because:
- they got rid of the dislike button — which leads to the spread of toxic content.
- even if you know that it's AI-slop, a scam post, deceptive, misleading, or fake news — you cannot share this signal with other users. Comments don’t work.
- if the post/video author blocks comments for provocative content — you simply cannot respond in any way.
Works for X, YouTube, Instagram, Bluesky, Truth Social, Threads, and more platforms to come…
https://reality-check.info

value: Show HN: Reality Check – Like, dislike, review, fact-check social media posts

author: AndreiBargan


value: vanshitmdotcom

value:
I got tired of using JSON tools that either don’t work properly on Windows, feel clunky, or just look painfully outdated.
At work, we deal with huge, messy JSON files every day, and I realized this frustration can’t be just mine—there must be a lot of devs facing the same thing.
So I built zeroformat.com.
Right now, it has:
JSON Viewer
JSON Formatter
JSON Validator
Simple, fast, clean UI — no login, no registration, just open and use it. Plug-and-play.
I’m actively building more tools, and honestly, if it grows — great. If not, my team and I will still use it daily
But if you work with JSON often, I’d genuinely love for you to try it and share feedback.
https://zeroformat.com
In case you are busy and directly want to try the tool ,
https://zeroformat.com/json-formatter
If it helps you even a little, that’s a win.

value: Show HN: Free Developer Tools – JSON, Base64, URL Encoder

author: vanshitmdotcom


value: jcoughenour

value:
I had 2 weeks of holiday vacation and I wasn't interested enough to work on my other long running projects so I decided to get into GBA homebrew when my brother gifted me a Game Boy Advance SP for Christmas. I was going to remake Wordle but someone else already did that so Bloxorz was my second choice.
Most of the hard work is done by the Butano engine: https://github.com/GValiente/butano
I'm also using go to process the original assets and prerender the static part of the levels.
It runs on real hardware but you can (ironically) play it now in the browser thanks to EmulatorJS: https://nostabyte.itch.io/bloxorzgba
I might writeup a full tech breakdown of how it works at some point if anyone is interested.

value: Show HN: I ported classic flash game Bloxorz to Game Boy Advance

author: jcoughenour


value: vinkupa

value:
Claude Code doesn't remember anything across sessions.
Code reviews with Opus-4.5 are already expensive. Amnesia makes it worse - same nits, same false positives, every single time.
So I built a Claude Code skill that reviews uncommitted files, and actually remembers past scans via Turingmind - A lightweight cloud layer that syncs issue metadata between sessions)
https://github.com/turingmindai/tmind
If a previous scan's issue got fixed, It recognizes that explicitly.
A file keeps having auth bugs? It applies deeper checks automatically.
Flagged an issue last week that's still there? It reminds you.
Your code stays local. Only issue metadata syncs (file paths, issue types, dismissals).
Privacy-first.
After a couple weeks it genuinely feels like a reviewer who knows your codebase instead of a bot starting fresh every time.

   /plugin marketplace add turingmindai/tmind

   /tmind:setup

   /tmind:login

   /tmind:review

   /tmind:deep-review

MIT licensed. Would love feedback — local memory coming soon

value: Show HN: Claude Code Review Skill with Memory - Saves me $$$ on Opus 4.5 tokens

author: vinkupa


value: troelsfr

value:
Hey HN,
I just published a two-volume book series called "The AI-Augmented Developer's Rust Series."
The core thesis: AI coding assistants have fundamentally lowered the barrier to using Rust. You no longer need to be a Rust expert to be productive—the AI handles the syntax, and the compiler handles correctness.
But there's a problem with AI-assisted development that nobody talks about enough: errors compound. You prompt, AI generates, you accept, you prompt again. Each small mistake builds on the last. And because things are running 100 miles per hour, the compound is fast. In dynamic languages, you often don't discover the accumulated mess until you're deep in a codebase you can't easily recover from.
Rust breaks this cycle - at least partially. The compiler forces you to confront issues immediately—before they compound. Or rather it forces AI to confront these issues upfront. Issues are fixed as you go, not six months later in a production incident.
The other insight: Rust covers the full stack. Yew for WebAssembly frontends, Axum for backends. One language, one mental model, shared types between client and server and strong typing although through to your database!
Would love the hear from you what tech stack you've had the most success with using AI? And with the time you save on coding, are you experimenting, figuring out what works best for you or how are you using the time you gain?

value: Show HN: Two Rust books for developers who use AI coding assistants

author: troelsfr


value: photonboom

value: Show HN: I built a robot to win at Mario Party minigames

author: photonboom


value:
Quick update on the StatefulSet Backup Operator I shared last week.
Based on early feedback and code review, I've made several improvements:
What's new in v0.0.2-alpha:
Container name specification for pre/post backup hooks (you can now target specific containers in multi-container pods)
Proper error handling throughout the codebase (fixed unchecked errors that linters were complaining about)
Added unit tests for core reconciliation logic
Cleaner code structure following Go best practices
Still experimental, but getting more stable. The operator automates PV snapshots for StatefulSets using Kubernetes VolumeSnapshot API, with backup policies defined as CRDs.
Looking for feedback on feature priorities:
I'm trying to figure out what would make this actually useful beyond a learning project. Some ideas I'm considering:
Application-aware backup hooks (e.g., MySQL flush before snapshot)
Backup verification/validation
Better observability (Prometheus metrics)
Restore automation (currently manual)
Multi-cluster snapshot replication
Which of these (or other features) would matter for real-world usage? Or is Velero already solving all these problems well enough that narrow-scope alternatives don't make sense?
Appreciate any thoughts from folks running stateful workloads on Kubernetes.

value: Show HN: StatefulSet Backup Operator v0.0.2 – Added tests and hooks improvements


value: hrshw

value:
Hi HN,
I built SubTrack to help teams find unused SaaS tools and cloud resources
before they silently eat into budgets.
The motivation came from seeing how hard it is to answer simple questions:
– Which SaaS tools are actually used?
– Which cloud resources are idle?
– What will our end-of-month spend look like?
SubTrack connects to tools like AWS, GitHub, Vercel, and others to surface
unused resources and cost signals from one place. Recently I added
multi-account support, currency localization, and optional AI-based insights
to help interpret usage patterns.
This is an early-stage project and I’m actively iterating.
I’d really appreciate feedback—especially from people managing cloud or SaaS
sprawl.

value: Show HN: SubTrack – A SaaS tracker for devs that finds unused tools

author: hrshw


value: rbajp

value:
Hi HN,
I built Pane, a spreadsheet-native agent that operates directly on the grid
(cells, formulas, references, ranges) instead of treating spreadsheets as text.
Most spreadsheet AI tools fail because they:
- hallucinate formulas
- lose context across edits
- can't reliably modify existing models
Pane runs inside the spreadsheet environment and uses the same primitives a human
would: selecting cells, editing formulas, inserting ranges, reconciling tables.
I launched it on Product Hunt this weekend and it unexpectedly resonated, which
made me curious whether this approach actually holds up under scrutiny.
I'd love feedback on:
- obvious failure modes you expect
- whether this is fundamentally better than scripts + formulas + copilots
Happy to answer technical questions.

value: Show HN: Pane – An agent that edits spreadsheets

author: rbajp


value: fiveleavesleft

value:
I built Sutra, a Chrome extension that helps you perform intelligent searches and analyses on your own browsing history.
Instead of scrolling through a long list of URLs, you can ask questions like:
“What are the clothing-related sites I’ve visited?”
“What news related to Gaza have I read?”
“What do I usually browse late at night?”
“Which links do I visit most often?”
“What did I open around the time I was on Etsy yesterday?”
Sutra turns your browsing history into something you can actually explore, understand, and reflect on. These analyses can be done either through natural language searches or via predefined operations.
Privacy & AI
All data stays local on your machine.
No browsing history is sent to any server by default.
AI usage is optional and user-controlled.
You can use a local LLM (e.g. via Ollama) or a cloud model if you choose.
GitHub: https://github.com/paulrahul/sutra
Privacy policy: https://github.com/paulrahul/sutra/blob/main/PRIVACY_POLICY....
Would love your feedback and suggestions.
used AI to compose this post as I'm traveling without my laptop

value: Show HN: Intelligent search and analysis for your browsing history

author: fiveleavesleft


value: bojan-ch

value:
If you've ever had to provision network equipment in a datacenter, you know the drill: standing next to a loud rack, laptop balanced on a shelf, serial cable too short. I got tired of this and so the journey of the intertooth started.
The first prototype was hacked together in a weekend: just a Bluetooth module wired to a serial chip. It worked, but it was just bare circuit boards held together with hope. Still, it changed how I worked. No more standing at the rack.
I showed it to my colleague Jürg. He immediately asked: "Can it do USB consoles too?" Then: "What if you forget it plugged in somewhere?" That evening we sat down and made a list of everything that would make this thing actually useful day-to-day. Integrated battery. USB and RJ45 ports. An alarm so you don't leave it behind. Different LED colors so you know which unit is which when you're working on multiple devices.
That was years ago. Since then we've gone through countless revisions, fixed things we didn't know were broken, and used it daily in our own work. It's now at a point where I finally feel comfortable showing it to others.
Would love to hear your thoughts, especially if you've dealt with the same serial cable frustrations.

value: Show HN: From Weekend Hack to the Serial Console Adapter We Enjoy Using

author: bojan-ch


value: blixt

value:
I went exploring whether using LLM tokens as the individual "digits" of random ids would let you get more randomness for the same number of tokens, and the answer is yes. Using the current strategy in this library is about ~50% more token efficient than using base64 ids.
I also ran hundreds of sessions against the OpenAI API to see if the logprobs would look off using this strategy, compared to base64 ids, and it seems like it's about the same or possibly slightly better (more "peaky").
Could be useful for agentic frameworks where tool results need to provide ids to refer back to later. A small win at best, but it was fun to explore!

value: Show HN: Create LLM-optimized random identifiers

author: blixt


value: yiyiyayo

value: Show HN: Convert bank statement PDFs to Tables

author: yiyiyayo


value: liambre

value: Show HN: ETLR – An alternative to Zapier/Make/n8n for developers (YAML-based)

author: liambre


value: sunpy

value: Show HN: AI Motion Control – Transfer any motion to any character with Kling AI

author: sunpy


value: prvt

value:
Hi HN,
I recently noticed a recurring visual artifact in the "Most Replayed" heatmap on the YouTube player. The highest peaks were always surrounded by two dips. I got curious about why they were there, so I decided to reverse engineer the feature to find out.
This post documents the deep dive. It starts with a system design recreation, reverse engineering the rendering code, and ends with the mathematics.
This is also my first attempt at writing an interactive article. I would love to hear your thoughts on the investigation and the format.

value: Show HN: Reversing YouTube‘s “Most Replayed” Graph

author: prvt


value: sureshcsdp

value: Show HN: CleanCloud – Cloud cleanup that can't delete anything

author: sureshcsdp


value: Show HN: mcp-apps-kit - Build AI apps for MCP Apps and ChatGPT from one codebase


value:
I’m used to having good observability for systems and workflows, but now that I generally start development with Claude Code vs my IDE, I lost a layer of visibility into how my code is produced.
Subtle (https://github.com/itsderek23/subtle) is a free, open-source app for analyzing Claude Code logs that runs entirely on your local machine. It lets you:
* See overall Claude Code usage over time (broken down by AI vs tool time)
* Count Claude-assisted Git commits over time
* Visualize individual sessions with a trace showing how time is spent
* Filter sessions by message text
* View session transcripts
I don’t yet know what “good” Claude Code usage looks like ... fewer interventions? Smaller commits and PRs? Lower code churn within a session? Would love your thoughts.

value: Show HN: Subtle – Local, open-source analytics for Claude Code sessions


value: binalpatel

value: Built this for myself but thought it was useful enough to share. It's essentially a server/client setup that lets you plug in arbitrary Pydantic-AI agents. All the state is handled server side which lets you create/use thin clients (TUI + Web for now) to interact with the agents.<p>I run this on a Linux server with Tailscale, then I can connect to and interact with the agents from any device on my Tailnet (so TUI from my laptop, web interface from my phone).

value: Show HN: Server for Pydantic-AI Agents

author: binalpatel

title: Show HN: Server for Pydantic-AI Agents


value: Show HN: Gdocs-CLI – Fetch Google Docs as Markdown for AI Coding Agents


value: tusharnaik

value:
Greetings HN,

  I built Forage because I kept running into the same problem: I had a few tens of thousands of records in my main database, that needed full-text search, but standing up Elasticsearch felt like overkill. The alternatives were either clunky database LIKE queries or maintaining a sync pipeline to a dedicated search cluster.

  Forage is a Java library that builds a Lucene index directly in your application's memory. You pull data from your database, index it locally, and search with zero network hops.

  What it does:
  - Lucene power: fuzzy matching, phrase queries, boolean logic, range queries
  - Function scoring for custom ranking (field boosting, decay functions, scripts)
  - Cursor-based pagination
  - Stays in sync with your database through periodic bootstrapping
  - First-class Dropwizard integration

  When it makes sense:
  - Dataset fits in memory (up to ~1M documents)
  - You want microsecond search latency, not milliseconds
  - You don't want to operate search infrastructure when you have data in an existing relational / non-relational setup

  When it doesn't:
  - You need distributed search across nodes
  - Dataset exceeds heap memory
  - Real-time indexing of high-velocity streams

value: Show HN: Java In-Memory search using Forage

author: tusharnaik


value: ayushpawar

value:
I built image0.dev, a small set of image utilities that run completely in the browser.
There’s no backend.
No uploads.
No tracking.
No accounts.
All image processing happens locally using browser APIs and web workers. Once loaded, it works offline.
Current features:
 • Compress images
 • Resize images
 • Convert formats (PNG / JPG / WEBP)
 • Batch processing (including folders)
 • Before / after preview
 • EXIF metadata removal

value: Show HN: Image0.dev – image tools that run in the browser

author: ayushpawar


value: Show HN: Senlo - self-hosted open-source email management system


value: akopich

value: Show HN: Woid – 3x Faster Runtime Polymorphism. C++23

author: akopich


value: WillNickols

value:
Hey HN! We’re Will and Jorge, and we’ve built LAD (Language-Aided Design), a SolidWorks add-in that uses LLMs to create sketches, features, assemblies, and macros from conversational inputs (https://www.trylad.com/).
We come from software engineering backgrounds where tools like Claude Code and Cursor have come to dominate, but when poking around CAD systems a few months back we realized there's no way to go from a text prompt input to a modeling output in any of the major CAD systems. In our testing, the LLMs aren't as good at making 3D objects as they are are writing code, but we think they'll get a lot better in the upcoming months and years.
To bridge this gap, we've created LAD, an add-in in SolidWorks to turn conversational input and uploaded documents/images into parts, assemblies, and macros. It includes:
- Dozens of tools the LLM can call to create sketches, features, and other objects in parts.
- Assembly tools the LLM can call to turn parts into assemblies.
- File system tools the LLM can use to create, save, search, and read SolidWorks files and documentation.
- Macro writing/running tools plus a SolidWorks API documentation search so the LLM can use macros.
- Automatic screenshots and feature tree parsing to provide the LLM context on the current state.
- Checkpointing to roll back unwanted edits and permissioning to determine which commands wait for user permission.
You can try LAD at https://www.trylad.com/ and let us know what features would make it more useful for your work. To be honest, the LLMs aren't great at CAD right now, but we're mostly curious to hear if people would want and use this if it worked well.

value: Show HN: AI in SolidWorks

author: WillNickols

title: Show HN: AI in SolidWorks


value: KyleVlaros

value: Show HN: Securing Docker Builds

author: KyleVlaros

title: Show HN: Securing Docker Builds


value: afterxleep

value:
You work from the terminal now. Your editor has better AI. But Xcode still breaks your flow.
I got tired of switching to Xcode 15+ times an hour while building in Cursor. So I built FlowDeck.
What it does:
Native Swift CLI with interactive mode: B builds, R runs, K cleans, L streams logs
JSON output for CI/CD and AI agents — xcodebuild output is chaos, this isn't
Simulator and device management for iOS, watchOS, tvOS, visionOS
Free VS Code/Cursor extension with LLDB debugging
Technical details:
- Native Swift, not a Node.js wrapper
- 100x faster scheme discovery than xcodebuild -list
- One abstraction over xcodebuild, simctl, devicectl, xcrun
- Works with any .xcodeproj or .xcworkspace
Try it:
curl -sSL https://flowdeck.studio/install.sh | sh
cd [YOUR_XCODE_PROJECT_DIR]
flowdeck -i
7-day free trial, no credit card. $29/year after. Extension is free forever.
Happy to answer questions about the implementation or the Apple tooling pain that led to this.

value: Show HN: FlowDeck – Stop switching to Xcode just to hit Build

author: afterxleep


value: segov

value:
> *TL;DR:* On larger features, Claude’s plans tend to get vague, which leads to vibe-coded spaghetti in the implementation. This plugin forces PRD + design + task-level acceptance criteria to keep things grounded.
Hi HN,
I use Claude Code a lot and it's native plan mode works well for small to medium changes, but on larger features the plans would be vague, which lead to more hallucinations during implementation.
I ended up coming up with a manual workflow for larger features where I'd write a design first by bouncing ideas back and forth with ChatGPT/Claude/Gemini until I had something broken down into clear phases. I’d drop those docs into the repo and then have Claude Code implement each phase individually while referring back to them.
So I made ShipSpec, a Claude Code Plugin that automates this workflow inside Claude Code. It generates three repo-local markdown files:
* PRD.md – requirements
* SDD.md – design doc
* TASKS.md – ordered tasks with acceptance criteria
Because tasks link back to both the requirements and the design, Claude Code stays grounded during implementation.
Usage:
```
/shipspec:feature-planning "add user authentication with OAuth2"
/shipspec:implement-feature auth-feature
/shipspec:implement-task auth-feature TASK-001
```
Not sure if this is generally useful or just scratches my own itch, but curious if others have hit similar issues with having Claude Code implement larger features.

value: Show HN: Spec Driven Development Plugin for Claude Code

author: segov


value: sawirricardo

value: Show HN: Cozy Cafe – A browser-based idle clicker game, made with Claude Code

author: sawirricardo


value: qudent

value: Show HN: Claude skill+design pattern for managing worktrees for parallel agents

author: qudent


value:
Hi HN,
I built Sidecar (https://sidecar.bz) because I was having issues maintaining a social media presence for my last startup. I would spend a lot of time trying to create content, but I often froze up or burned out, and the marketing died.
How it works: Instead of guessing what to write, Sidecar connects to your existing accounts (Threads, Bluesky, Mastodon, Facebook, Instagram) and analyzes your past posts to see what actually worked.
It uses that data to generate weeks of new, text-based content that mimics your successful posts, which you can then bulk schedule in one go.
I’d love to hear what you think of Sidecar. You can use code HNLAUNCH for a free month if you want to test the ai features.

value: Show HN: Sidecar – AI Social Manager (Analyzes past hits to write new posts)


value: logicalsam

value:
I found that many people like myself who run tech companies, agencies, or other types of businesses will often need to ask their clients for various secrets (env files, passwords, access codes, fried chicken recipes...), and there was no tool out there that felt like it was made for that job.
I explored password managers, "one-time link"-type sites, self-hosted, SaaS... none of them had the simplicity I was looking for, for myself and for my clients.
So, I spent my Christmas annual leave building this. keyhold.io is a zero-knowledge custody of secrets platform with a fixed monthly rate, designed not to compete with password managers, but to have alongside a traditional password manager exclusively for client-owned secrets.
Clients can submit secrets into your team's Hold, fully end-to-end encrypted, and they can auto-expire or be deleted on-demand by your client.
This is my first proper go at being a business man/founder/techbro, so I'd love any and all feedback (even if it rips me to shreds). I'm sure I've got a lot of lessons to learn!

value: Show HN: I made a zero-knowledge tool to request clients' secrets

author: logicalsam


value: Louis-Nicolas

value:
Hi HN! We’re Charles, Victor, Jules, and Louis-Nicolas from Lettria (https://www.lettria.com ).
We’ve been building RAG and agentic systems on top of large, messy document corpora (PDFs, reports, internal docs, Markdown). In practice, we kept running into the same problem: unstructured text is easy to read, but hard to reason over.
Vector search helps, but once you need multi-hop reasoning, consistency across documents, domain rules, or to understand why an answer is correct, we kept wanting explicit structure. In every project, we ended up rebuilding the same glue: parsing documents, extracting entities and relations, enforcing domain logic, exporting TTL, loading into a graph store, then wiring retrieval on top.
So we pulled that work out into a small SDK we could actually reuse.
Perseus is a Python SDK that turns text documents (Markdown / TXT) into explicit knowledge graphs (Turtle .ttl), optionally guided by an ontology, and usable for GraphRAG, agents, or analytics.
At a high level:
 • Input: Markdown / TXT
 • Optional: ontology (or none)
 • Output: .ttl knowledge graph
 • Optional: push directly into Neo4j
The SDK is async-first, intentionally small, and opinionated around producing inspectable entities and relations rather than just embeddings.
We include:
 • a simple “build graph” example
 • an end-to-end GraphRAG example: PDF → Markdown → KG → report
(infra reproducible with Docker Compose: Neo4j, Qdrant, embedder)
How to try it:
pip install perseus-client==1.0.0-rc.1
Repo:https://github.com/Lettria/perseus-client/
We’re running a very open early access for the next few weeks, with generous free limits so people can actually experiment without worrying about quotas. API keys are available here if you want to try the full pipeline: https://app.perseus.lettria.net/app/
We’d really appreciate feedback from people building GraphRAG or agent memory systems — especially what feels awkward, missing, or unnecessary. Happy to go deep in the comments.

value: Show HN: Perseus – A Python SDK to turn text into knowledge graphs (GraphRAG)

author: Louis-Nicolas


value: ericlmtn

value: Monitor the situation to your own liking. Polymarket, Subway Surfers, Bluesky integration, Flight trackers. Runs all requests client side and doesn't store information. Open to feedback.

value: Show HN: Customizable OSINT dashboard to monitor the situation

author: ericlmtn


value: rafalgawlik

value:
Hey HN,
I've been running my own homelab for 4+ years (2 servers, 15+ services).
After helping friends set up theirs, I noticed the same pattern: they'd
spend weeks piecing together random tutorials, debugging YAML indentation,
and giving up before getting anything running.
So I built Homelab Creator - a structured course + ready-to-deploy Docker
Compose configs.
What's included:
- 12-lesson Docker fundamentals course (from zero to docker-compose)
- 15 production-ready service configs (Jellyfin, Nextcloud, Gitea, Grafana, etc.)
- 6 remote access guides (Cloudflare Tunnels, Traefik, WireGuard, Tailscale)
- All configs tested on both x86 and ARM (Raspberry Pi)
Tech stack: Next.js, hosted on Vercel, payments via Stripe.
I know there's tons of free content out there. The value here is having
everything organized, tested together, and beginner-friendly in one place.
Not for everyone - if you're already running 20+ containers, you don't need this.
Launch price is $19.
Happy to answer any questions about the technical setup or the configs themselves.
https://homelab-creator.com

value: Show HN: Homelab Creator – Docker course and configs for self-hosting

author: rafalgawlik


value: samarthahathwar

value: Show HN: Spec-Driven AI – A Markdown state manager for Claude Code

author: samarthahathwar


value: heavenlxj

value:
Hi HN,
We recently made a deliberate decision to rebrand our AI product from Kinkora to Conut.
This wasn’t about marketing or aesthetics. It came from a shift in how we understood the real problem creators face.
When we first launched, we focused heavily on prompting — helping users get better results from a specific model. Over time, we noticed a pattern:
Most friction didn’t come from starting a generation, but from what happens after.
People wanted to:
Compare outputs across models
Enhance or extend generated images
Turn results into videos or new variations
Iterate without starting from scratch
Prompting alone didn’t solve that.
So alongside the rebrand, we:
Redesigned parts of the UI around iteration, not one-shot generation
Added support for more models and creative modes
Started building toward an editor-style workflow, where post-generation control is first-class
Conut is still early, but the direction is now clearer:
AI as a creative workspace, not a prompt box.
Happy to answer questions or hear critiques — especially from anyone building tools in the creative or AI space.

value: Show HN: Conut.ai – We rebranded our AI creative tool

author: heavenlxj


value: Finbarr

value: Show HN: Yolobox – Run AI coding agents with full sudo without nuking home dir

author: Finbarr


value: sarusso

value: Show HN: Fall asleep by watching JavaScript load

author: sarusso


value: Yinp

value: Show HN: Creaibo – AI Rewriter

author: Yinp

title: Show HN: Creaibo – AI Rewriter


value: todaycompanies

value: Show HN: Compare Contractor Quotes – AI to parse and normalize renovation bids

author: todaycompanies


value: mayankkgrover

value:
Hey HN! This is Mayank from Outscal with a new update. Our website is now live.
Quick context:  we built a tool that generates animated videos from text scripts. The twist: instead of rendering pixels, it outputs React/TSX components that render as the video.
Try it: https://ai.outscal.com/
Sample video: https://outscal.com/v2/video/ai-constraints-m7p3_v1/12-01-26...
You pick a style (pencil sketch or neon), enter a script (up to 2000 chars), and it runs: scene direction → ElevenLabs audio → SVG assets → Scene Design → React components → deployed video.
What we learned building this:
We built the first version on Claude Code. Even with a human triggering commands, agents kept going off-script — they had file tools and would wander off reading random files, exploring tangents, producing inconsistent output.
The fix was counterintuitive: fewer tools, not more guardrails. We stripped each agent to only what it needed and pre-fed context instead of letting agents fetch it themselves.
Quality improved immediately.
We wouldn't launch the web version until this was solid. Moved to Claude Agent SDK, kept the same constraints, now fully automated.
Happy to discuss the agent architecture, why React-as-video, or anything else.

value: Show HN: AI video generator that outputs React instead of video files

author: mayankkgrover


value: mehulfanawala

value: An all-in-one app that teaches children financial literacy through pocket money, chores, rewards, goals, and bite-sized money lessons.

value: Show HN: JebKharch – Pocket money and financial literacy for kids

author: mehulfanawala


value: mgmx-io

value:
Hey everyone,
I usually use sparrow for monitoring on desktop, but I wanted a simple way to check my Bitcoin balance on my phone
I didn’t want to expose xpubs or use a mobile wallet that also handles transactions. I was just looking for something watch-only
So I built BitScout, a small tool that lets me add Bitcoin addresses and see their combined balance and transactions
There are no ads, no accounts, and no analytics. Addresses stay on the device. Each one is checked separately using the mempool API
I’ve been using it for a while and found it useful, so I figured I’d share and see what others think
Happy to answer questions
App Store:
https://apps.apple.com/us/app/bitscout-track-bitcoin-wallet/...
Source code:
https://github.com/mgmx-io/BitScout

value: Show HN: I built a watch-only Bitcoin address tracker for iOS

author: mgmx-io


value: namin

value: Show HN: Holey: Staged execution from Python to SMT for synthesis

author: namin


value: ogorun

value:
Hi HN,
I built a small tool to help reason about configuration changes.
You paste an old config, a new config, and optional context (e.g. “AWS ECS + RDS Postgres, production traffic”), and it explains what changed and what might be operationally risky.
The motivation is very simple: config diffs are easy to see syntactically, but much harder to reason about operationally. Increasing a pool size, changing timeouts, toggling a feature flag — all of these look trivial in a diff, but can have non-obvious impact in production.
This is not meant to replace reviews or deep system knowledge. It’s closer to a “second pair of eyes” that summarizes changes and points out things worth thinking about.
No accounts, no setup. Just paste → explain → share if useful.
Live demo: https://configdiff.net
Happy to hear feedback, criticism, or ideas for improvement

value: Show HN: ConfigDiff – understand what a config change does

author: ogorun


value: Show HN: Henri: a small, hackable agent CLI


value:
Hey HN — long-time reader, second-time Show HN.
I built Snuper[1], a small utility for inspecting and consuming live DraftKings prop data directly from their WebSocket feeds.
The original itch came from building a live sports app where I wanted real-time betting lines and prop updates without relying on delayed REST endpoints or polling. DraftKings already streams this data — it’s just not documented.
Snuper connects to the WebSocket, listens for message frames, and exposes structured prop updates in real time. No scraping, no headless browsers — just listening to the same stream the site uses.
What it does:
- Connects to DraftKings WebSocket feeds
- Decodes and surfaces live prop updates
- Useful for real-time dashboards, analytics, or experimentation
- Minimal, transparent, and easy to inspect
What it doesn’t do:
- No automation, no betting, no bypassing auth
- No attempts to modify or interfere with traffic
- Read-only observation of publicly delivered data
It’s intentionally small and focused — meant as a building block, not a product.
Open to any feedback :)

value: Show HN: Snuper – A WebSocket "snooper" for live DraftKings props


value: mrdonbrown

value:
Claude Code is amazing for individuals but terrible for teams.
I spent the last six months building my perfect mix of MCP servers, subagents, commands
and skills. Claude Code writes 100% of the code now, but sharing this with my team? Painful.
1. Blog posts and workshops don't work (and don't scale)
2. Committing tools to N repos means N PRs. A tool changes? N more PRs.
3. Same tools, different files or folders for each AI assistant; not everyone uses Claude Code
It is like 1999 all over again; FTPing files up to prod and versioning with ".bak" suffixes.
So I built sx. It is your team's private NPM for Claude Code (and others).
How it works:

  # Set a git repo as your vault
  sx init --type git git@github.com:my-org/sx-vault.git

  # Add a local skill, command, mcp, etc
  sx add my-skill

When your team installs sx, they automatically get the right versioned tools for the right
projects (mono-repos too!).  No more PRs, no more stale docs, no more tedious brownbags.
Supports Claude Code and Cursor today. Others soon.
Claude Code wrote every line of sx. How'd it do? :)
GitHub: https://github.com/sleuth-io/sx

value: Show HN: Sx – I fixed Claude Code for teams

author: mrdonbrown


value: kalanigrowney

value:
Over the past three months, I’ve been working with my dad on this app as a way to learn Cursor, shadcn/ui, and Next.js. I’m currently studying UX design at the University of Michigan, and I’ve been really impressed by how much vibe-coding tools have advanced over the last six months.
This work journal includes private AI-generated insights with scheduled summaries that can be shared with your team or manager. You can also choose to make a summary public—like I’ve done here for my work on this web app:
https://www.workjourney.ai/summary/mkblt2zt-hn2kdbus
If anyone has feedback or suggestions on how I could improve my design or coding skills, I’d really appreciate it.

value: Show HN: Sophomore at UMich, built an app with my dad

author: kalanigrowney


value: FlowM

value: Show HN: BitStory – a Bitcoin-native protocol for on-chain time capsules

author: FlowM


value:
Hey HN, I’m the founder of SyncAI.
Previously, I was building internal tools for a fintech startup. We tried using GPT-4 Vision and various OCR APIs to automate our Accounts Payable. They worked great for ~90% of documents.
The problem was the other 10%: crumpled receipts, handwritten delivery notes, or invoices with weird layouts. In fintech, a 90% success rate isn’t automation; it’s a liability. We spent more time fixing the AI’s hallucinations than if we had just typed it manually.
I realized that for high-stakes operations, we didn’t need "better AI"—we needed a Safety Layer.
So I built SyncAI. It’s an extraction API that guarantees "Golden Records" (verified data) by routing uncertainty to humans.
How it works under the hood:
Ingestion: You send a PDF/Image via API.
Ensemble Extraction: We run it through a mix of OCR and LLMs to extract key fields.
Confidence Scoring: We calculate a confidence score for each specific field (not just the whole doc).
The Routing Logic:
If Confidence > 99% (and passes regex validation) → Auto-Approve (Returns JSON instantly).
If Confidence < 99% → Routes to HITL (Human-in-the-Loop) queue.
Verification: A human verifies only the low-confidence fields in a split-screen UI.
Callback: Your webhook receives the strictly typed, verified JSON.
We are positioning this for developers building Autonomous Finance Agents who need deterministic inputs.
I’ve set up a playground where you can try it without signing up. Upload your messiest invoice/receipt to see if we can parse it: https://sync-ai-11fj.vercel.app/
Pricing is usage-based (per doc). The documentation is here: https://sync-ai-11fj.vercel.app/docs.
I’d love to hear your feedback on the routing architecture or how you’re currently handling "AI hallucinations" in production pipelines.

value: Show HN: API that falls back to humans when AI is unsure


value: il-b

value:
It's helpful to have a short summary line in your ChatGPT results:
[Certainty: 9/10 | Evidence: consensus (2006) | Dispute: minor (2023) | Temporal: stable (2025) | Sources: IAU.org (2006); NASA.gov (2024)]
To add it, paste the following prompt into your Profile - Personalization - Custom instructions text area and press Save
--
For informational or structured answers, add a compact epistemic summary line immediately below each major section title, formatted in square brackets.
The line should include:
• Certainty (1–10) based on external documentation or well-established knowledge; be conservative when evidence is limited or interpretive.
• Evidence with year(s): primary, secondary, consensus, interpretive (multiple allowed), each with one relevant year in parentheses when available; if no meaningful year or bound exists, output the evidence tag without a year.
• Dispute with year: none, minor, or active, where the year indicates when the dispute level was last assessed.
• Temporal with year, labeled Temporal: timeless, stable, or time-sensitive, indicating when stability was last evaluated.
• Sources with year(s), labeled Sources, using compact identifiers (DOI, RFC, book/chapter/verse, or short stable domains).
Keep the bracketed line short, standardized, and scannable. Do not inflate certainty; reflect uncertainty clearly in the score and indicators.

value: Show HN: Epistemic Summary Line for ChatGPT

author: il-b


value: wiso

value: Show HN: ASCII based Figma like editor

author: wiso

title: Show HN: ASCII based Figma like editor


value:
hi hn ! i've been experimenting with text-to-image models since the launch of DALLE. one thing i've noticed is that each provider (openai, google, black forest labs) has their own API params to control things like moderation, prompt upscaling, etc. this makes it difficult to know  what knobs need to be turned to optimize for common goals like cost, speed of render, quality, etc
i built param forge to provide a TUI interface to explore those knobs and get automated feedback on could be optimized to help you achieve your goals
interacting with image models via CLI seems a bit counterintuitive but i've found this approach helpful
mostly looking for feedback, any other problems / annoyances you have in this space etc
:)

value: Show HN: Param forge, image gen TUI with rounds that improve settings


value: tommihip

value:
Hi HN,
There’s been a lot of discussion lately around context graphs, decision traces, and how AI systems reason.
One thing we kept running into:
when AI agents make real decisions, the why behind those decisions often disappears.
The context is scattered across prompts, tools, policies, and approvals. Logs show what happened, but not why it was allowed.
TraceMem is an attempt to make decision context durable.
It records the reasoning, authority, and context behind AI actions as a system of record, not as monitoring data, but as memory.
Happy to share more details or answer questions.
- Tommi

value: Show HN: TraceMem – A trace-native memory layer for AI agent decisions

author: tommihip


value: mojoatomic

value:
Most "atomic" deployment scripts aren't atomic.
If you're using the standard symlink swap pattern for zero-downtime deploys, you've probably seen this:
bash
ln -sfn releases/20260112 current
Looks atomic. It's not. Run it through strace:
symlink("releases/20260112", "current") = -1 EEXIST
unlink("current") = 0
symlink("releases/20260112", "current") = 0
There's a window where current doesn't exist. Under load, some requests get ENOENT.
The fix is well-documented for Linux:
bash
ln -s releases/20260112 .tmp/current.$$
mv -T .tmp/current.$$ current
The mv -T calls rename(2) which atomically replaces the symlink. Problem solved.
Except on macOS. BSD mv doesn't have -T, and it follows symlinks differently. The Capistrano/Deployer communities have known about this for over a decade. Most just accept the race condition on Mac, or tell you to develop on Linux.
I needed something that works on both (MSP managing mixed fleets - Linux servers, Mac dev machines, CI runners on both). The solution turned out to be Python's os.replace(), which calls rename(2) directly:
bash
if [[ "$platform" == "linux" ]]; then
    ln -s "releases/$rel_id" "$tmp_link"
    mv -T "$tmp_link" "current"
else
    ln -s "releases/$rel_id" "$tmp_link"
    python3 -c "import os; os.replace('$tmp_link', 'current')"
fi
I wrapped this in a deployment script with:
* Platform detection (GNU vs BSD coreutils)
* Directory-based locking with stale PID detection
* Automatic rollback on SIGINT/SIGTERM
* State machine cleanup (knows whether to rollback vs just clean up temp files)
Single bash script, no runtime dependencies beyond python3 (which is everywhere now).
GitHub: [https://github.com/mojoatomic/atomic-deployments.git]
Q: Why not just use Capistrano/Deployer/Shipit?
A: Those are great if you're already in that ecosystem. I needed a single script I could drop into any CI pipeline without pulling in Ruby/PHP/Node. Also, Deployer's own code shows it falls back to non-atomic on systems without mv -T.
Q: Why not use containers/Kubernetes?
A: Not everyone is on k8s. Lots of us still deploy to VMs, bare metal, edge devices. Symlink swaps are still the simplest zero-downtime pattern for those environments.
Q: Python dependency defeats the "no dependencies" claim
A: Fair. But python3 ships with macOS and virtually every Linux distro. It's as close to "always there" as you get. The alternative is writing a small C binary, which creates a different dependency problem.
Q: What about NFS/network filesystems?
A: Don't. rename(2) atomicity guarantees don't hold across network filesystems. This is for local filesystems only.
Q: What about the renameat2() RENAME_EXCHANGE flag?
A: That's Linux 3.15+ only and requires glibc 2.28+. It does a true atomic swap of two paths, which is even better. But it's not portable, so I stuck with the symlink + rename pattern that works everywhere.
Q: Does this handle shared directories (logs, uploads, etc.)?
A: Not in scope for this script. It just does the atomic swap. Capistrano-style shared directory symlinking is a separate concern.
Key technical points
1. ln -sfn is unlink + symlink, not atomic
2. mv -T on Linux calls rename(2) which IS atomic
3. BSD mv follows symlinks, breaking the pattern
4. Python's os.replace() calls rename(2) directly on all POSIX systems
5. Capistrano's workaround (create symlink in subdirectory, mv with relative path) works but requires their Ruby runtime
6. The script detects platform by checking if mv --version returns GNU, not by uname (more reliable for edge cases like GNU coreutils on Mac via Homebrew)

value: Show HN: Atomic symlink deployments that work on macOS URL

author: mojoatomic


value: ufarooqi

value: Show HN: Superwiser -- A plugin that remembers how you steer Claude Code

author: ufarooqi


value: durutti

value: Show HN: I vibe coded a site to virtually crate dig for new music

author: durutti


value: ilikebits

value:
Hey HN! At work, we've been experimenting with adding asynchronous agents into our development workflow. One challenge we've discovered is that agents have a really hard time following style rules in long-running tasks, no matter how much we beg or repeat these rules in our AGENTS.md.
To fix this, we've built Nudge. Nudge watches the code that Claude writes, and uses its Hooks API to prompt Claude with style rules whenever a rule violation is detected. This helps ensure rules that are loaded much earlier in the session (e.g. when reading AGENTS.md) are not forgotten later on during a long-running task or session. It's especially helpful for long lists of simple stylistic rules (e.g. "only add import statements at the top of the file") that are easy to forget.
You can see our full write-up at https://www.attune.inc/blog/nudge and you can use the tool today at https://github.com/attunehq/nudge. We hope this helps solve this pain point for other folks as well!

value: Show HN: Nudge – Enforcing guardrails for coding agents

author: ilikebits


value: eyrockscript

value:
I'm a developer from Mexico. I wanted to create programming courses in Spanish
  for Latin America, where quality tech education is expensive or English-only.

  Instead of spending a year writing content, I used Claude Code to build the
  entire platform — code, lesson content, everything.

  The result:
  - 6 complete courses: Tech Fundamentals, Frontend (React/TS), Backend (Java/Spring),
    Auth, DevOps (Docker/K8s/Terraform), and Cloud (AWS/GCP)
  - 220+ interactive lessons with quizzes, exercises, and code examples
  - Certificate system with verification codes
  - Final exams to gate certificates
  - Learning paths for different career goals
  - Stripe payments

  Tech stack: React 18, TypeScript, Vite, Tailwind, shadcn/ui, Supabase, Stripe

  The irony isn't lost on me: it's an "AI-First Academy" that teaches developers
  to use AI tools effectively... and was itself built entirely with AI.

  Content is in Spanish (targeting Latin America), but happy to discuss:
  - The process of building with Claude Code
  - What worked and what didn't
  - Whether AI-generated educational content is "good enough"
  - Prompts and approaches I used

  Repo is private but happy to share code snippets if anyone's curious about
  specific implementations.

value: Show HN: I built a 220-lesson programming academy using only Claude Code

author: eyrockscript


value: peoray

value: Show HN: AI Elements Vue – A Port of Vercel's AI Elements UI Library

author: peoray


value: bridelamb

value: Fun module on Thales of Miletus—the beginning of philosophy

value: Show HN: Modern Philosophy Course

author: bridelamb

title: Show HN: Modern Philosophy Course


value: hookedonwinter

value:
I built this to solve my own newsletter overload problem. Turns out there are similar tools that I found after I basically launched (Meco, Mailbrew), but turns out mine is a bit simpler and less opinionated about how you consume content.
Core features:
- Three ingestion methods: auto-forward from Gmail, manual forwarding, or sign up with your dedicated email address
- Web dashboard to browse all newsletters in one place
- Scheduled email digests (configurable times, skips if nothing new)
- Save/star functionality for read-later
I've been using it for a few weeks, and it's really helped me. I set mine to arrive at 8am and 1pm. The save feature is nice, too.
Tech: Django, OpenAI for summarization, hosted on Hetzner. Email parsing is surprisingly gnarly—lots of edge cases with different newsletter formats.
Free for now, likely paid tiers eventually. Feedback welcome!
Link: https://hiddensignal.app
Screenshot of a recent digest: https://imgur.com/a/tuTBYKV

value: Show HN: Hidden Signal – Newsletter digest with web dashboard and scheduling

author: hookedonwinter


value: IKnowMazin

value: My first custom kubernetes controller for scaling individual endpoints in hpa fashion.

value: Show HN: Endpoint Scaling Kubernetes Controller

author: IKnowMazin


value:
I've been researching blockchain-based capital markets and developed a framework for tokenized equity with separated economic, dividend, and governance rights.
Core idea: Instead of bundling everything into one share, issue three token types: - LOBT: Economic participation, no governance - PST: Automated dividends, no ownership - OT: Full governance control
Key challenge: Verifying real-world business operations on-chain without trusted intermediaries. I propose decentralized oracles + ZK proofs, but acknowledge significant unsolved problems.
This is research/RFC seeking technical feedback on oracle architecture, regulatory viability, and which verticals this makes sense for.
Thoughts?

value: Show HN: Blockchain-Based Equity with Separated Economic and Governance Rights


value: puildupO

value:
I started using Facebook at the age of 13, for many hours every day. The same happened with other social media apps.
I recently found that Facebook alone made around 14K from my daily usage over the years.
I paid with my time and attention, and they made money from it.
Seeing the number made me less addicted and more careful.
It showed me that my time is actually expensive.

value: Show HN: I found that Facebook made around 14K from my daily usage

author: puildupO


value:
Lately I've been getting a ton of ads for a device called Brick https://getbrick.app/ which is an NFC tag that you have to scan in order to unlock distracting apps on your phone. I really like the idea, and since I had an ESP32 with a screen laying around I figured that I could use this instead.
I made a simple iOS app that uses the Screen Time API to block a selection of apps. Once blocked, you have to scan the QR code on the ESP32 screen. This QR code is updated every 30 seconds using the TOTP algorithm (which is used by authenticator apps). It only uses a hardcoded shared key and the current timestamp, so there is no need to make the ESP32 and the iPhone communicate together. You do need to connect the ESP to WiFi at boot to sync its clock via NTP.
This design allows the QR code to be displayed on anything (e.g. a web page), but having it on a dedicated device adds more friction, which we want!

value: Show HN: I made a physical app blocker with ESP32


value: todaycompanies

value: Show HN: I built a tool to calculate the True Cost of Ownership (TCO) for yachts

author: todaycompanies


value: paulefizelier

value: Show HN: Idlen.io ($IDL), the first privacy-first AI ad network is launched

author: paulefizelier


value: tesserato

value: Define systems using a minimal, declarative syntax with only *6 keywords* (`constant`, `variable`, `error`, `group`, `function`, `import`), with instant feedback via errors, warnings and an interactive graph to explore complex systems.

value: Show HN: Minimal type-safe language for software architecture

author: tesserato


value: volokh

value:
Hi! My name is Kirill, I am developing yoth-yoth, a platform that combines canvas boards, pages, task tracker, calendar and much more (but in the future). The boards and the raw version of the pages are currently available. Here is a quick intro on using the boards: https://yoth-yoth.com/b/help
For basic use, the platform is free and requires no registration, and all data is stored locally in the browser. Data synchronization and collaboration with other users are available by subscription.
There are a lot of things in the plans, for example, the task tracker and calendar mentioned earlier, sharing of boards, pages and other objects.
I will be glad to hear your feedback.
PS: For some reason, Monaco Editor (the library that displays the code on canvas) is not friendly with the library that I use to work with canvas in Safari and on mobile devices, so the elements may be blurred. I'm working on fixing this issue.

value: Show HN: Yoth-yoth – your all-in-one workspace

author: volokh


value: Hey, I built this because Screen Studio is amazing, but incredibly expensive. My solution is a native Mac app with the same functionality (smart zooms, full fledged video editor) with a price that doesn't make you shiver.

value: Show HN: I made a $25 lifetime Screen Studio alternative


value: egordev

value:
Hey HN - I built ProofLoop, an open-source CLI orchestrator for long-horizon agent work.
My pain with agents on real projects: big tasks degrade into babysitting (continue -> fix regression -> rerun -> repeat). They stop too early - so you can’t step away.
ProofLoop’s approach: you write a Definition of Done once, then it keeps planning/executing/verifying until the whole contract is satisfied. The “done” contract can include high-level, plain-text acceptance criteria
Example run:
proofloop run "Implement a complete feature from scratch: API endpoints, database schema, frontend components, full test coverage" \
  --path ./project --provider codex --timeout 8
Providers/adapters: OpenCode, Codex (ChatGPT), Claude Code. Local-first. Apache 2.0.
Repo:
https://github.com/exiw-ai/proofloop
Install:
curl -LsSf https://raw.githubusercontent.com/exiw-ai/proofloop/main/ins... | sh
Would love feedback / war stories from anyone running agents on multi-hour tasks. Thanks!

value: Show HN: ProofLoop – Autonomous long-running agents with verifiable completion

author: egordev


value: rosenx

value: Show HN: AI Prompt Generator, Optimizer and Manager

author: rosenx


value: thebigship

value:
I am working on a platform for creating and sending postcards from open access museum collections.
I've integrated the Met, Cleveland Museum of Art and AIC, with an experimental feature for Wikimedia Commons.
If you want to send a postcard you can use the promo: 2SWEET to send a postcard to whoever for 2 dollars off. Before discount the price is $3 for US and $5 for international.
Any feedback or questions are welcome.

value: Show HN: Create Postcards from Museum Artworks

author: thebigship


value: oug-t

value: Show HN: ZSweep – A keyboard-first Minesweeper inspired by Vim

author: oug-t


value: yazeedaloyoun

value:
I built proc because I was tired of:
- Googling "how to find process using port" every time
- The cognitive load of lsof -i :3000 | grep LISTEN | awk '{print $2}'
- Forgetting which flag does what in ps aux
proc uses natural patterns:
  proc on :3000     # What's on port 3000?
  proc kill node    # Kill all Node processes
  proc ps --in      # Processes in this directory
  proc tree -a 1234 # Where did this process come from?
Written in Rust, works on macOS/Linux/Windows.
GitHub: https://github.com/yazeed/proc
Install: brew tap yazeed/proc && brew install proc
Happy to answer questions!

value: Show HN: Proc – A semantic CLI for process management

author: yazeedaloyoun


value: huppp

value:
I wanted to share a TikTok without my username going with it and popping up to the receiver, or TIkTok's advertising backend. What started as a
simple question turned into a rabbit hole.
TikTok's links embed referrer parameters that identify who shared the
link. Facebook's share link wrapper includes session hashes.
YouTube's `si=` parameter likely logs the share against your profile. Etc. Etc. Etc. Etc.
Each platform implements this differently, and they change their schemes regularly. So I built a secure modular cleaner with a constantly updating database, after carefully inspecting the behavior of each platform.
The app uses a deny-by-default security model. If it doesn't recognize a parameter,
it gets stripped. Behavior is configurable, and I tried to make it as self-explanatory as possible, and hopefully educational about exactly what the app does on your behalf and exactly what the platforms are doing with their parameters.
I feel like there's a kind of "physics" to internet interaction we used to understand intuitively.
Click a link, go to a page. Share a link, send a URL. But platforms have been eroding
this. Now sharing means sending a URL + your identity + session context + attribution
metadata, all encoded in ways we can't read.
I built PrivateLink to scratch my own itch for that transparency, paired with one-touch sharing integration. The app shows you what's in the link,
what gets stripped, and why. The goal isn't just "clean URLs" — it's understanding
what happens when sharing from any app.
Available on iOS and Android, with a free version that cleans TikTok and Facebook shortlinks specifically, and a $0.99 pro unlock for any website.
Any and all feedback greatly appreciated!

value: Show HN: PrivateLink – Stop TikTok and others from embedding your info in links

author: huppp


value: zdunecki

value: Show HN: Selfhosted – One click self hosted apps

author: zdunecki


value: stewardyunn

value: Show HN: I built an image-to-3D tool optimized for 3D printing and game asset

author: stewardyunn


value: raihaninfo

value:
Hi HN,
I'm Raihan, a developer from Bangladesh. I built ToolsAid because I was tired of using ad-filled, slow utility sites that often upload sensitive data (like JWTs or JSON configs) to their servers for processing.
ToolsAid is a privacy-focused, all-in-one developer toolkit.
Key Features:

    Privacy-First: For sensitive tools like the JSON Formatter, JWT Decoder, and RSA Key Generator, the logic runs entirely in your browser. Your data never leaves your device.

    Blazing Fast: The backend is built with Golang, making the site incredibly lightweight and fast.

    40+ Utilities: Includes SQL Playground, Visual Cron Job Generator, Regex Tester, and even a Branded QR Code Generator for freelancers.

    Ad-Free: No ads, no signups required.

It's a passion project, and I'd love to get your feedback. Let me know what you think!
Link: https://toolsaid.com

value: Show HN: ToolsAid – A privacy-first developer utilities hub built with Golang

author: raihaninfo


value: AJASU

value: You can check the diagram of architecture on the github and spec/updates on design-spec folder

value: Show HN: A custom little core CPU architecture with a unique pipeline design

author: AJASU


value: hanzili

value:
Open source maintainers are drowning in low effort PRs.
Someone sees a help wanted issue, pastes it into an AI, submits without testing, loops through review comments without understanding the code. The PR looks plausible at first glance but falls apart under review. Maintainers waste 30 minutes before realizing it's garbage.
This is happening at scale now. And it's worst in projects with bounty programs or GSoC where there's incentive to “contribute.”
GitHub tells you if someone is a first-time contributor to your repo. It doesn't tell you anything about their history elsewhere.
I built a Chrome extension that shows contributor reputation right on the PR page: merge rates across repos, spray-and-pray patterns, red flags.
Not sure I got the signals right. Would love feedback from maintainers.

value: Show HN: SlopScore – Contributor Reputation for GitHub PRs

author: hanzili


value:
Hi HN,
I built a CLI tool that generates documentation from Drizzle ORM schema definitions.
The problem: Drizzle ORM doesn't have built-in schema documentation or ER diagram
generation. While drizzle-dbml-generator exists for DBML output, I needed something
that could also extract JSDoc comments and generate human-readable documentation.
What it does:
- Extracts JSDoc comments from your schema and includes them in the output
- Generates DBML (compatible with dbdocs.io and dbdiagram.io)
- Generates Markdown documentation with Mermaid ER diagrams
- Supports PostgreSQL, MySQL, and SQLite
- Works with both Drizzle v0 (relations()) and v1 beta (defineRelations()) APIs
- Watch mode for development
Example:
  drizzle-docs ./src/db/schema.ts -o schema.dbml
  drizzle-docs ./src/db/schema.ts -f markdown -o ./docs
The key differentiator is JSDoc extraction. If you document your schema like this:

  /** User account information */
  export const users = pgTable("users", {
    /** Unique identifier */
    id: serial("id").primaryKey(),
    /** User's email address */
    email: varchar("email", { length: 255 }).notNull(),
  });

These comments become Notes in DBML or descriptions in Markdown output.
Built with TypeScript, uses the TS Compiler API for comment extraction.
MIT licensed.
Would love feedback on what output formats or features would be most useful.

value: Show HN: Drizzle ORM schema to DBML/Markdown/Mermaid documentation generator


value:
Hi Hacker News,
First post, hope it's all a-ok!
My partner and I had a baby this year. For their first birthday my partner wanted to print a big (a0) sized square of 365 photos one photo per day, in order.
All existing solutions (including Canva) either crashed or outputted a very small, non-print friendly file.
So I made her one.
* You give it a folder of photos.
* It sorts them by EXIF date.
* It lays them out in a square grid.
* It reserves a center space for a title.
* It outputs a print-ready file.
* No uploads, no accounts, no tracking.
* Works fully offline.
It’s intentionally opinionated, you don't really design, you feed it photos and enjoy the output.
I might add intelligent cropping at one point, the way we did it:
* Crop photos, transfer to PC, run script -> print
I’m open-sourcing it because heaps of people at the party wanted to do something similar, so maybe some of you will find it useful.
This has been tested in the real world and indeed produced an a0 poster in 500dpi.
Thanks for reading.

value: Show HN: A script that turns 365 photos into a square year poster


value: divyenduz

value: Show HN: Incus-Sandbox-SDK

author: divyenduz

title: Show HN: Incus-Sandbox-SDK


value: broxdeez

value:
I built Arcane, a minimal terminal-based chat interface for LLMs written in Go.
Features:
- Terminal UI (TUI)
- Multiple model/provider support
- Conversation history
- Lightweight config
- Written in Go
Repo: https://github.com/bm611/arcane

value: Show HN: Arcane – minimal AI chat TUI

author: broxdeez

title: Show HN: Arcane – minimal AI chat TUI


value: mohitgangrade

value:
Hi HN
I noticed that anyone doing outbound or market research ends up rebuilding the same SaaS company list over and over again.
Scrape some sites, export from tools, clean it up… then dump it into an enrichment tool and start paying per lead. Felt wasteful.
So I built SaaSCSV.com: a one-time CSV with ~40k SaaS companies you can reuse as a base and only enrich when it actually matters.
No emails in the file (on purpose). Company data lasts, emails don’t.
Posting mostly to see if others have felt the same “why am I rebuilding this again?” pain.
Happy to answer questions.

value: Show HN: I built a reusable 40k SaaS company list

author: mohitgangrade


value: ahmetomer

value: Show HN: HN Print – turn Hacker News stories into a printable newspaper

author: ahmetomer


value:
- real quake-style terminal using ghostty framework
- window finder/jumper
- searchable and usable command pallet for any app
- App menu anywhere
- Niri tabs
- Niri and Dwindle layout
- Hide/unhide status bar icons
- Interactive workspace bar
- Animations<p>A lot more features to list or remember them all...

value: Show HN: Omni Animated Tiling WM for macOS (Niri and Hyprland)


value: svendson

value:
Hi HN,
I'm the creator of IT Word Search Labs.
I built this because I enjoy word puzzles but found that generic ones (fruits, animals, etc.) were a bit boring. I wanted something that felt relevant to my day-to-day work as a developer.
It’s a simple web app that generates word search puzzles based on IT terminologies, covering topics like Python, Web Development, Cyber Security, and more.
How it works:
  It uses React for the UI. The grid generation algorithm places words randomly with collision detection to ensure a valid board every time.
Features:
  Tech-specific dictionaries.
  Clean, distraction-free interface (no ads).
  Printable mode (for offline use or classrooms).
It's a fun little side project to kill time while waiting for builds to complete.
I’d love to hear your feedback on the UI or suggestions for new word categories.
Thanks!

value: Show HN: IT Word Search Labs – A Word Search Game for Tech Learners

author: svendson


value: ponny

value:
Hi HN!
I created Bugbop over the last year now I'm officially releasing it!  It’s a platform for teams that want to run their first bug bounty without expensive contracts.  I come from a SaaS technical founder background where I ran our program for years.  Now I've decided to make something better suited to that niche.
The model is simple: only pay when valid vulnerabilities are found.  No ongoing subscriptions.  Set budgets to avoid going over.  The app's still in the early days but it's working: security bugs are getting paid and bug hunters are getting bounties.
It's using AI to review check if it's in scope, detect duplicates, and set severity (the app doesn't ask reporters because everyone just says "Critical").
I’m interested in feedback from people who’ve run bug bounties, stopped running them, or considered them and decided against it.

value: Show HN: Bugbop – a smaller bug bounty platform

author: ponny


value: FreshmanD

value: Show HN: LoongFlow – Directed evolutionary search framework for LLM agents

author: FreshmanD


value:
Hi HN,
I built pdf-rfc3161, a lightweight pure JavaScript/TypeScript library for embedding trusted RFC 3161 timestamps into existing PDFs. It runs in Node, Cloudflare Workers, and browsers - no native dependencies.
Great for proving a document existed at a specific time without full digital signatures. Supports LTV for long-term validation (embeds cert chains and revocation info).
Live demo: https://mingulov.github.io/pdf-rfc3161/
GitHub: https://github.com/mingulov/pdf-rfc3161
npm: https://www.npmjs.com/package/pdf-rfc3161 (latest released version is 0.1.3)
There's also a CLI: npx pdf-rfc3161-cli
It is early days - feedback very welcome! Missing features, real-world use cases, or improvement ideas?
Thanks!

value: Show HN: Pdf-rfc3161 – Pure JavaScript library for RFC 3161 PDF timestamps