Show stories

I wanted to run markdown files like shell scripts. So I built an open source tool that lets you use a shebang to pipe them through Claude Code with full stdin/stdout support.

task.md:

    #!/usr/bin/env claude-run

    Analyze this codebase and summarize the architecture.

    chmod +x task.md

    ./task.md

A script that runs your tests and reports results (`run_tests.md`):

    #!/usr/bin/env claude-run --permission-mode bypassPermissions

    Run ./test/run_tests.sh and summarize what passed and failed.

    cat data.json | ./analyze.md > results.txt

    git log -10 | ./summarize.md

    ./generate.md | ./review.md > final.txt

    for f in logs/\*.txt; do

        cat "$f" | ./analyze.md >> summary.txt

    done

One thing we didn't expect is that these are more auditable (and shareable) than shell scripts. Install scripts like `curl -fsSL https://bun.com/install | bash` could become:

    `curl -fsSL https://bun.com/install.md | claude-run`

The (really cool) executable markdown idea and auditability examples are from Pete Koomen (@koomen on X). As Pete says: "Markdown feels increasingly important in a way I'm not sure most people have wrapped their heads around yet."

We implemented it and added Unix pipe semantics. Currently works with Claude Code - hoping to support other AI coding tools too. You can also route scripts through different cloud providers (AWS Bedrock, etc.) if you want separate billing for automated jobs.

GitHub: https://github.com/andisearch/claude-switcher

What workflows would you use this for?

I built a macOS menu bar app to track Claude usage in real time via API after hitting limits mid-flow too often.

Signed and notarised by Apple. Open source.

https://github.com/richhickson/claudecodeusage

https://x.com/richhickson

My name is Adrian. I'm a Software Engineer and I spent 6 years developing a perimeter-based geofence-based social media app.

What it does:

- Allows you to load a custom perimeter anywhere on the geographic map (180° E and W longitude and 90° N and S latitude), to cover area any area of interest

- Chat rooms get loaded within the perimeter

- You can chat with people within the perimeter

I developed a mobile app that uses an advanced geofence-based networking system from 2013 to 2019. My goal was to connect users within polygon geofences anywhere in the world. The app is capable of loading millions of polygon geofences anywhere in the world.

https://enterpriseandroidfoundation.com/assets/images/other/...

But people didn't really have a need for this. So after failing, I spent the next 6 years trying new ideas to use FencedIn for. I tried a location-based video app and a place-based app that had multiple features. Nothing worked, but now I'm almost finished developing ChatLocal, an app that allows you to load a perimeter anywhere on the geographic map, which loads chat rooms.

The tech stack is 100% Java (low-level mostly). I have a backend, commons library and an Android app. Java was the natural choice back in 2013. However, I still wouldn't choose anything else today. Java is the best for long-term large-scale projects. (I'm also using WildFly. PostgreSQL and a Linux server.)

This app is still not fully finished, but I think the impact on society might be tremendous.

The previous app to ChatLocal, LocalVideo, is fully up on the Google Play store and can be tested. It has 88% of the features of ChatLocal, including especially the perimeter-based loading system.

The feedback I'm mostly looking for is new ideas and concepts to add to this location-based social media app. And how strong of a value proposition does the app have for society.

Hi HN,

I’m experimenting with commit-based code review as an alternative to PR-based review.

Instead of analyzing large PR diffs, this reviews each commit incrementally, while context is still fresh. It’s fully configurable and intentionally low-noise, high signal - focused on catching issues that tend to slip through and compound over time.

The goal isn’t to replace CI or PR review, but to move some feedback earlier:

risky changes hidden in small diffs

architectural or consistency drift

performance or security footguns

Happy to answer questions

I forked a PyTorch DeepDream implementation and added video support with temporal consistency. It produces smooth DeepDream videos with minimal flickering, and is highly flexible including many parameters and supports multiple pretrained image classifiers including GoogLeNet. Check out the repo for sample videos! Features:

- Optical flow warps previous hallucinations into the current frame

- Occlusion masking prevents ghosting and hallucination transfer when objects move

- Advanced parameters (layers, octaves, iterations) still work

- Works on GPU, CPU, and Apple Silicon

Wall Street pays up to $3k/mo for terminals. They have access to better & faster datea, that's why they win.

The playing field is changing...

We built a Wall Street terminal for independent traders and investors.

Real-time breakouts, smart money tracking, AI-powered analysis, Congress trades...

All in one place, at a fraction of the cost.

Each moving arrow represents one real bike ride out of 291 million, and if you've ever taken a Citi Bike before, you are included in this massive visualization!

You can search for your ride using Cmd + K and your Citi Bike receipt, which should give you the time of your ride and start/end station.

Everything is open source: https://github.com/freemanjiang/bikemap

Some technical details: - No backend! Processed data is stored in parquet files on a Cloudflare CDN, and queried directly by DuckDB WASM

- deck.gl w/ Mapbox for GPU-accelerated rendering of thousands of concurrent animated bikes

- Web Workers decode polyline routes and do as much precomputation as possible off the main thread

- Since only (start, end) station pairs are provided, routes are generated by querying OSRM for the shortest path between all 2,400+ station pairs

Hey everyone, I made this thing: https://tryflux.ai/

Context: I've tried probably 15 different AI apps over the past year. ChatGPT, note-taking apps, productivity apps, all of it. But most of them are just clutter on my iphone.

They live in some app I have to deliberately open. And I just... don't. But you know what I open 50 times a day without thinking? iMessage. So out of mild frustration with the "AI app graveyard" on my phone, I built Flux.

What it does: - You describe a personality and what you want the agent to do - In about 2 minutes, you have a live AI agent in iMessage - Blue bars. Native. No app download for whoever texts it.

The thesis that got us here: AI is already smart enough. The bottleneck is interaction. Dashboards get forgotten. Texts get answered.

This was also my first time hitting #1 on Product Hunt, which was surreal.

We're very early and probably broke something. If you try it, feedback is super welcome, weird edge cases, "this doesn't work," or "why would anyone use this" comments all help.

That's all. Happy to answer questions.

Hi HN,

I rebuilt my side project into a small “all-in-one” image toolbox: https://imagesplitter.tools

The part I’m most proud of (and personally use the most) is the collage workflow:

1. Grid collage (templates + merge cells for “one big + many small” layouts)

2. Long-image stitching (great for screenshots / step-by-step guides / chat logs)

3. Freeform collage (DIY your own grid layout — split/merge cells however you want — then apply that layout to the grid collage)

My motivation was pretty simple: I kept bouncing between different sites for basic image chores, and many of them add watermarks, require login, or feel sketchy for privacy. So I made this with a few strict rules:

1. Free, no watermark 2. Privacy-first: processing happens locally in the browser (no upload/storage)

Besides collages, it also includes common utilities I often need:

crop (free/aspect/circle/shape), grid split + ZIP export, batch convert (JPG/PNG/WebP/ICO…), compress, images→GIF, text/markdown/html→image, QR generate/decode, color picker, image info, etc.

I’d really love feedback:

1) What’s the most annoying part of making collages / long images?

2) Any “must-have” features you’d expect for this kind of tool?

Thanks for taking a look — happy to iterate based on your comments.

The article discusses the author's experience of designing an overly complex Dungeons & Dragons character sheet, highlighting the balance between functionality and simplicity in game design and application development.

PokerBench is my attempt at a new LLM benchmark wherein frontier models play Texas Hold'em in an arena setting. It also features a simulator to view individual games and observe how the different models reason about poker strategy. Opus/Haiku, Gemini Pro/Flash, GPT-5.2/5 mini, and Grok 4.1 Fast Reasoning have all been included.

All code -> https://github.com/JoeAzar/pokerbench

Hi HN! I built Image Scaler because I was frustrated with existing free online image tools. They either limit batch processing to a handful of images, require login/registration, or add watermarks. And they usually upload your images to unknown servers.

I originally made this for myself when I needed to resize large batches of product photos. I wanted something fast, lightweight, and privacy-respecting that could handle real workflow volumes without artificial restrictions.

What makes it different:

- Complete client-side processing using Canvas API, so images never leave your browser

- Batch processing up to 60 images simultaneously (most free tools cap at 3-10)

- No login, no watermarks, no usage limits

- Traditional interpolation algorithms (nearest-neighbor, bilinear, bicubic) instead of AI black boxes

- Supports JPG, PNG, and WebP

- Fast and lightweight (built with vanilla JavaScript)

Technical notes: The entire processing pipeline runs in your browser's Canvas API. There's no server upload step, which eliminates privacy concerns and makes it surprisingly fast even for large batches. I chose traditional algorithms over AI because they're transparent, predictable, and work well for most use cases (pixel art, web images, photo preparation).

Feel free to try it out: https://image-scaler.com

A fast SOCKS5 proxy that tunnels your traffic through what looks like normal SMTP email, bypassing Deep Packet Inspection firewalls.

How it works: - Client runs a local SOCKS5 proxy (127.0.0.1:1080) - Traffic is sent to server disguised as SMTP (EHLO, STARTTLS, AUTH) - DPI sees legitimate email session, not a VPN/proxy

Features: - One-liner install on any Linux VPS - Multi-user with per-user secrets and IP whitelists - Auto-generated client packages (just double-click to run) - Auto-reconnect on connection loss - Works with any app that supports SOCKS5

Tech: Python/asyncio, TLS 1.2+, HMAC-SHA256 auth

GitHub: https://github.com/x011/smtp-tunnel-proxy

Hi HN,

I built Layoffstoday, an open platform that tracks tech layoffs across ~6,500 companies.

What it does:

Aggregates layoff events from public news sources

Normalizes data by company, date, industry, and affected headcount

Shows historical patterns instead of isolated headlines

Why I built it: During job transitions, I noticed people had to jump across news articles, spreadsheets, and social posts just to answer simple questions like “Has this company laid people off before?” or “Is this happening across the industry?”

This is an attempt to make that information structured, searchable, and accessible.

Would love feedback on:

Data accuracy / gaps

Signals that would actually help job seekers

Whether alerts or trend indicators are useful or noisy

Chris Wiles showcased his setup for Claude Code and I thought it was sick. So I adapted it for Django projects. Several skills have been added to address the pain points in Django development.

I would like to share an open database focused on link-level metadata extraction and aggregation, which may be of interest to researchers.

The project maintains a structured dataset of links enriched with metadata such as:

- page title

- description / summary

- publication date (when available)

- thumbnail / preview image

- etc.

The goal is to provide a reusable, inspectable set of link metadata that can be used for experiments in areas such as:

- RSS and feed analysis

- news analysis

- link rot analysis?

The database is publicly available here:

https://github.com/rumca-js/RSS-Link-Database-2025

There are also databases for previous years

Just build a local tool for designing gears that kinda looks and works nice

My agency was bleeding $1,800/year on contractor Notion seats. The problem: I needed to give contractors access to specific data (CRM, project tracker) but couldn't let them see pricing, margins, or other clients' information.

Notion's native solution doesn't work:

Row-level filtering exists but it's view-only (contractors can't edit)

Column hiding doesn't exist

Guest sharing is read-only

So you either pay $15/mo per seat or duplicate databases (maintenance nightmare)

I built a permissions layer using Notion's OAuth API. It lets contractors see only specific rows and columns, edit data, all without expensive seats.

How it works:

Connect Notion via OAuth

Define roles: "Sales reps see only leads where owner = them, hide pricing column"

Contractors access a clean portal

They view/edit data in real-time (syncs every 5 minutes)

You pay $59/mo flat for unlimited users

The math:

5 contractors × $15/mo = $900/year wasted

20 contractors × $15/mo = $3,600/year wasted

50 contractors × $15/mo = $9,000/year wasted

With this: all of them = $59/mo flat.

Technical:

Frontend: React + TypeScript

Backend: Supabase + PostgreSQL (RLS)

Auth: Notion OAuth 2.0

Current state: 50 beta testers. First 20 customers get $49/month locked-in (launching at $79 after January).

Limitations:

Only Notion databases (not pages)

5-minute sync (not instant)

Requires role definition

No team permissions yet (roadmap)

The ask: If this solves a problem you have, we'd love feedback. Are there permission use cases we're missing? What's your price sensitivity?

Free trial: notionportals.com

Author here! Some context: I published this 48 hours ago and it was auto-listed on MCPMarket (the MCP tools directory). Got 700+ organic downloads with zero marketing—developers were actively searching for exactly this solution.

The "Git Accelerator" optimization story:

Initially used a file walker that took 6.6s on Chromium. Profiling showed 90% was filesystem I/O. The fix: git ls-files returns 480k paths in ~200ms. Added smart heuristics for untracked files (only scan dirs <50k files), bringing total to 0.46s.

Why this matters: Agents can't wait 10 seconds for search. Sub-500ms makes it feel instant, changing how they explore codebases.

Installation:

  Cursor: npx mantic.sh@latest
  VS Code: npx mantic.sh@latest
  CLI: npm i -g mantic.sh

Happy to answer questions!

Why - I got sick of apps abusing notifications on my Android phone. While the OS does give you the ability to switch off notifications based on channels, most apps either don't use it or abuse it intentionally. In my case, I live in a gated society that uses an app called MyGate to allow visitors, and the app intentionally pushes ads through the same channels since you cannot block them.

What - DoNotNotify is an app that logs all incoming notifications, and displays them grouped by app. It also captures the action behind the notification, which can be triggered from the app itself. From this log, you can create rules to whitelist/blacklist notifications from apps depending on their notification content. These filters can even be regex expressions, which allows for more complicated use-cases. The app ships with some pre-defined rules for popular apps like Facebook, Amazon, Instagram, Netflix, TikTok, Reddit etc.

Where - The website is at https://donotnotify.com/.

Would also like to call out that the app runs purely on your device, never communicates with anything on the Internet, and only requires notifications access to work. It is completely free, and there is no advertising or hidden gotchas.

Hi HN, Martin, Nils, and Jannes here.

We are building Legit, an open source version control and collaboration layer for AI agents and AI native applications.

You can find the repo here https://github.com/Legit-Control/monorepo and the website here https://legitcontrol.com

Over the last years, we worked on multiple developer tools and AI driven products. As soon as we started letting agents modify real files and business critical data, one problem kept showing up. We could not reliably answer what changed, why it changed, or how to safely undo it.

Today, most AI tools either run without real guardrails or store their state in proprietary databases that are hard to inspect, audit, or migrate. Once agents start collaborating on shared data, you are often just crossing your fingers and hoping nothing goes wrong.

We noticed something interesting. Developers do not have this problem when collaborating on code, and agent like workflows took off there first. The reason is relatively simple. Git already solves coordination, history, review, and rollback.

That insight led us to build Legit. We bring Git style versioning and collaboration to AI applications and to most file formats. Every change an agent makes is tracked. Every action is inspectable, reviewable, and reversible. No hidden state. No black box history.

Legit works as a lightweight SDK that AI apps can embed anywhere the filesystem works. It handles versioning, Sync, rollback, and access control for agens. Everything lives in a repository that you can host yourself or on any Git hosting provider you already trust.

We believe the right way to scale AI collaboration is not to hide what agents do, but to let developers and users see, review, and control every change. Legit is our attempt to bring the discipline, visibility, and safety of modern developer workflows to write enabled AI applications.

Give it a spin: https://github.com/Legit-Control/monorepo and let us know your feedback, criticism, and thoughts.

I've spent the last few months working on something I wish I'd had years ago. I kept running into the same issue: CI green, production mail broken. TLS handshake failures, DKIM alignment mismatches, SPF soft-fails ... the stuff that only surfaces when real mail servers are involved. Most test tools (Mailpit, MailHog) are catch-alls. They confirm "an email was sent" but don't validate the protocol. They also aren't designed for network-exposed environments: no auth, unprotected Web UI, easy to enumerate messages.

VaultSandbox is my attempt at fixing that. It's a self-hosted SMTP gateway (AGPLv3) that validates SPF, DKIM, DMARC, and rDNS on every incoming message. You keep your production email provider (Postmark, SendGrid, SES) in tests and you just change the recipient domain. No mocking, no config changes. There are client SDKs (Node, Python, Go, Java, .NET), plus a Web UI and a CLI for manual testing.

Some technical details:

Deterministic Tests Instead of polling or sleep loops, the SDKs use Server-Sent Events (SSE) so test assertions trigger the moment the mail hits the gateway.

Minimal infrastructure footprint Built with NestJS and Angular, with no external database dependency to keep the container footprint small and easier to reason about.

Post-Quantum Encryption I use ML-KEM-768 for the encryption layer. Incoming mail is encrypted immediately using a client-generated public key and the plaintext is discarded. The server only ever stores encrypted message data and cannot decrypt it. I chose PQ because I wanted to build something I wouldn't have to revisit in five years. If it handles large PQ keys reliably, everything else is easy.

Quick start: https://vaultsandbox.dev/getting-started/quickstart/

Site: https://vaultsandbox.com

I'd love feedback, especially on whether AGPLv3 would be a blocker for something you'd self-host in dev.

The article discusses Git Prime, a web-based tool that helps developers manage their Git repositories more effectively. It provides features like project monitoring, code review, and team collaboration to improve the software development workflow.

The article discusses the process of creating an animated sprite hero using JavaScript and HTML5 canvas. It covers key steps such as loading sprite images, managing animation frames, and implementing user interactions to control the hero's movement and actions.

Hi HN, I'm Barry and I've built Prism.Tools (https://blgardner.github.io/prism.tools/) – a collection of client-side developer utilities that respect your privacy.

Many of these tools were used way back in the days when I ran a BBS and started my communities first ISP, serving three local communities with Dial-Up Internet, Web Hosting etc. The tools have been refined to reflect the changes in tech since then and designed for the Novice and Pro alike. As I locate more tools others may find useful I will refine and add them to the collection. Use them, Share them, or not. They will be here if you need them...

40+ dev tools (JSON formatters, regex tester, base64 encoder, Git command helper, etc.) that run entirely in your browser. Zero tracking, zero analytics, zero data collection – everything processes locally. Self-contained HTML files with no build process or frameworks.

I realized I had a lot of tools/utilities I've built over the years for my own use. I lothe having to 'sign-up' just to access/use simple utilities that I can create myself. I've refined them and put them in one safe place so I could easily access them if/when needed. I decided to make them available via Github Pages for anyone that may find them useful. Prism.Tools is the result.

Each tool is a standalone HTML file with embedded CSS and JavaScript. No frameworks, no npm packages, no build steps – just open the file and it works.

The entire toolset:

- 100% client-side processing – your data never leaves your browser.

- No external dependencies except for specific libraries from cdnjs.cloudflare.com (marked.js for markdown, exifr for image metadata, etc.)

- Consistent dark UI – every tool follows the same design language for familiarity.

- Vanilla JS where possible – only reaching for Public CDN Resources when necessary.

The constraint of "single HTML file" was intentional. It forces simplicity and ensures tools remain maintainable. It also means users can inspect, modify, or self-host any tool trivially.

These tools have helped me with debugging production issues, Quick formatting tasks, learning Git commands (the Git command helper has been particularly helpful)

Just visit https://blgardner.github.io/prism.tools/ and try any tool. No signup, no install.

What tools are missing that you find yourself needing? Any performance issues with specific tools? UI/UX friction points?

All tools follow the same privacy-first philosophy... Your data stays in your browser. No accounts, no tracking, no servers processing your information. The project is also a demonstration that you don't always need React, Vue, or complex build pipelines – sometimes vanilla JavaScript in a single HTML file is exactly the right tool for the job.

Vanilla JavaScript (ES6+) CSS3 with CSS Grid Minimal external libraries: marked.js, exifr, highlight.js, sql-formatter (all from CDN) No frameworks, no bundlers, no npm Hosted on Github Pages

Happy to answer questions about the technical implementation, design decisions, or specific tools!

All tools are inspectable – just view source on any page to see exactly how they work!

I built this because Cursor, Claude Code and other agentic AI tools kept giving me tests that looked fine but failed when I ran them. Or worse - I'd ask the agent to run them and it would start looping: fix tests, those fail, then it starts "fixing" my code so tests pass, or just deletes assertions so they "pass".

Out of that frustration I built KeelTest - a VS Code extension that generates pytest tests and executes them, got hooked and decided to push this project forward... When tests fail, it tries to figure out why:

- Generation error: Attemps to fix it automatically, then tries again

- Bug in your source code: flags it and explains what's wrong

How it works:

- Static analysis to map dependencies, patterns, services to mock.

- Generate a plan for each function and what edge cases to cover

- Generate those tests

- Execute in "sandbox"

- Self-heal failures or flag source bugs

Python + pytest only for now. Alpha stage - not all codebases work reliably. But testing on personal projects and a few production apps at work, it's been consistently decent. Works best on simpler applications, sometimes glitches on monorepos setups. Supports Poetry/UV/plain pip setups.

Install from VS Code marketplace: https://marketplace.visualstudio.com/items?itemName=KeelCode...

More detailed writeup how it works: https://keelcode.dev/blog/introducing-keeltest

Free tier is 7 tests files/month (current limit is <=300 source LOC). To make it easier to try without signing up, giving away a few API keys (they have shared ~30 test files generation quota):

KEY-1: tgai_jHOEgOfpMJ_mrtNgSQ6iKKKXFm1RQ7FJOkI0a7LJiWg

KEY-2: tgai_NlSZN-4yRYZ15g5SAbDb0V0DRMfVw-bcEIOuzbycip0

KEY-3: tgai_kiiSIikrBZothZYqQ76V6zNbb2Qv-o6qiZjYZjeaczc

KEY-4: tgai_JBfSV_4w-87bZHpJYX0zLQ8kJfFrzas4dzj0vu31K5E

Would love your honest feedback where this could go next, and on which setups it failed, how it failed, it has quite verbose debug output at this stage!

The article discusses the issue of speeding in work zones, highlighting the risks it poses to workers and drivers, as well as the potential legal consequences of receiving a speeding ticket in a work zone.