Ask HN: What are tools you have made for yourself since the advent of AI?

I’ve also got a clang-repl wrapper for this codebase that is very easy to use and makes interactive programming much easier for me.

I made a scraper that searches through all the news and finds anything ‘war’ related. It then summarizes it and give me that new in the Star Wars crawl with music.

Wait, it would be easier for me to clone the whole thing and change one feature… What strange times we live in.

Plus after each run you get screen recordings with console logs, network requests, HARs, and Playwright traces so you can inspect exactly what the agent did 🙂

https://github.com/wizenheimer/canary

P.S. I attempted to do a Show HN but got flagged for some reason

https://github.com/DavidSeptimus/alfred-jetbrains-launcher

Mostly, I use it to quickly open projects in cmux, but I use it for switching between git worktrees in IntelliJ too.

– Snubnosed mandarin app. Vibecoded anki and tinder-like character game for mandarin which allows new vocab to be added on the fly. Also accurate text to speech for tones.

– What did I learn? Tweet summarize that takes all favored tweets and assembles into weekly categories and allows deep research on certain topics.

I am the only user. Sometimes it’s the process that matters, and exercising your brain is important too. I get that there is a lot of existential dread around AI taking our jerbs, and excluding humans from the process of creative work, but… you can still just write code, just for the personal satisfaction.

https://github.com/armyofevilrobots/bap-egui

So basically a way to just go on an hour long walk with myself, spit everything from the top of my dome stream of consciousness style, and then have Claude structure whatever I said.

It’s nice to have something that structures my thoughts by just thinking out loud.

I vibecoded it (it’s approaching 20K lines including tests). It works quite well but there are some bugs, so will have to do some actual engineering. But the UX is working quite well.

– https://github.com/exlee/pikchr_pl – DiagramIDE (diagram amiga-style workbench where you can script Pikchr diagrams using TCL, Prolog, Pikchr or – recently mruby). Note: you need to navigate to actual crate for description. There are binaries built in case someone wants to try it.

– https://svg.axk.sh – semi manual SVG fitter so that I can easier vectorize AI-generated pseudovector images (who doesn’t like 30kb SVG versus 1.8mb PNG?!)

– https://github.com/exlee/rik – this one makes me laugh every time I use it – it’s an AI harness with text editor as an UI (i.e. it reacts to comment strings) – I gave it personality so it makes wacky comments but other than that it’s very constrained agent (limited edition ;))

These are not vibe coded but AI made it much easier to slide through major friction points (e.g. for SVG fitter I really didn’t want to reinvent fitting algorithms)

This whole thread is turning HN into my favorite app store. Good stuff.

With Tailscale, you can basically point a domain to the FQDN of a machine you’re sharing with people and the domain will simply work for them (and only them)[1]. But for it to work without them having to know or specify the specific application port, you have to grant them access to 443 (and 80) in your Tailscale ACL for that specific host.

So yeah, now immich.familydomain.com works without family members having to remember the specific port. BUT, serveradmin.familydomain.com (another app on the same host) will ALSO be accessible to them (from a networking POV). We opened port 443/80 for that host after all.

I took a few hours with Claude back in January (?) and we wrote a tiny Go authorization gateway which basically consults both Tailscale’s public API and Tailscale’s `localapi` and returns the appropriate response to Caddy based on the requesting user’s actual allowed ports.

So now I can share different apps (subdomains) with different people without forfeiting access controls, all driven by Tailscale’s policy file.

(I hope I didn’t mess up the crux of it, pretty late here)

Edit: why not (something like) Authentik? Quoting from the draft:

  I contemplated this for a bit but one thing I kept thinking about is:

  _They're already logged in to Tailscale_

  Why do I need to install and configure another full-blown app dedicated to doing something Tailscale already did? Why have the users go through two hops of authentication?”

[1]: https://www.youtube.com/watch?v=Vt4PDUXB_fg

If tomorrow I decide not to share with anyone, I don’t want to have to reconfigure stuff. I simply edit the Tailscale policy file, and (maybe) spin down my server.

I probably would not have bothered to allocate time to this pre ai, the juice wasnt really worth the squeeze. But I approached it with an initial amusing naivete about it being ‘super simple’. As is almost always the case with software theres a reasonable amount of hidden complexity. But I have been using it as a sort of learning proving ground for how to work with agentic development. For example I got to a point where claude wouldnt implement properly and would argue with me about changes because it would read the current/old docs in the repo and get confused about reality. So right now I’m experimenting with ‘canonical specs’ that can only be changed modally with gates and a defined cascade from canon, to code, to docs in that order. Otherwise you end up in a weird thrash about the docs and the code disagree and which one will the agent decide to change for consistency?

Anyway, its been interesting and its v0.6 and at a point where Ive not hit a sharp edge dogfooding for a while and some beta testers would be valuable. Right now you have to manually wire it into your stack, once some others have kicked the tyres hard enough I will make some pr’s to the popular tools to consider integrating it.

Also used AI to design an online store (I’m not a front end dev). It’s amazing to see my wife (non-technical background) tweak the web-site using claude code.

End result: an online store where we sell jewelry pieces that actually are lambda-diagrams (Tromp diagrams) that compute Graham’s number, or of the Y-combinator (well, technically it’s just a fixed point operator, one beta reduction away from the Y-combinator. But Y-combinator was not aesthetically pleasing from a jewelry point of view)

store: Built a tool to help design cs/science inspired jewelry in CAD. I wrote a DSL to describe the jewelry, and had an LLM write the interpreter to generate a CAD file using cadquery (note to self: LLM suck at 3d reasoning). I would not have had the time to do this without AI.

Also used AI to design an online store (I’m not a front end dev). It’s amazing to see my wife (non-technical background) tweak the web-site using claude code.

End result: an online store where we sell jewelry pieces that actually are lambda-diagrams (Tromp diagrams) that compute Graham’s number, or of the Y-combinator (well, technically it’s just a fixed point operator, one beta reduction away from the Y-combinator. But Y-combinator was not aesthetically pleasing from a jewelry point of view)

store: https://studio-galois.com

A WebGl program that takes input like X123 Y123 Z123 via WebSerial every 100 ms and builds an object out of the resulting path. Required some performance optimizations (just had to tell it what to do). Also asked it to make the corners nicer and it did. (To be fair, I’d already asked a lesser model and put some things in the prompt to nudge it the right way.)

Various OpenSCAD models. E.g., remote control holder with 5 slots, staggered heights, slight slant because it looks cool, and the slots all have different depths. One shot. It implemented the slant/tilt using a shearing matrix. 100 points.

one trick on 3d reasoning: get it to draw all the different orientations, and you pick which one to use

it save a lot of time vs trying to tell it to rotate around Y and it actually rotates around X

What I often ended up doing is asking it to draw 3 labeled arrows X,Y,Z. So I could tell it to orient along the XY labeled arrows (which are in reality YZ, but whatever).

A self hosted web archiving tool with support for extendible processing pipelines (eg. extract article -> translate -> summarize -> generate tags, download video -> split audio track -> transcribe -> summarize), which led me to make a managed chromium browser with extensions and warc support for archiving, and a RSS feed synthesizer (take random article listing page that doesn’t have RSS and generate a feed for it) so that I can plug it into my archiver. An active learning loop for a model to clean up articles by removing junk like native ads and sponsored blocks.

A tabbed terminal with project management features like launching the database, app server, and claude code in different tabs with one click, and split browser/terminal panes (eg. opening a browser automatically at the correct URL when the terminal reads http://localhost:4000/).

A modular MCP server with a MCP proxy and OAuth2 dcr so that I can easily add new random ideas for MCP servers in a few minutes with Claude and deploy them such that it’s available to Claude by refreshing the tool list.

A small tool to render Claude conversations so that I can link to them from my obsidian vault with something like convo://claude-code/-home-jfim-projects-foo/

And overall just deploying docker containers for my self hosted setup

Most of it is on GitHub, in various states of readiness.

– Automated backups of steam saves for when my kids wanted to play the same game on my account and saves get out of sync with steam cloud. The kind of thing I wouldn’t usually bother with myself.

– automated script that reruns failed GitHub actions in repositories with flakey tests ‘cause why bother fixing them? It also auto catches up branches with the main branch for the repo.

– a YNAB extension for pi (agent harness) to help with entering purchases that need to be split across categories. This is also in the telegram bot so I can use voice-to-text to explain a purchase.

– I already had some python scripts to generate pdfs of Magic: The Gathering cards for printing proxies. I had an llm extend it to make some dividers with the set names and symbols on them. Makes organizing them a lot easier in the big card boxes.

Could I have done this myself? Of course. Would I have tho? Prob not.

This kind of simple, hyper-specific bespoke utility is the perfect thing for vibe coding IMO.

> I previously posted a Show HN about it, but it didn’t get traction

FYI your linked submission is marked as dead. Not sure if that’s a problem with your account or not. You should email the HN mods.

  ;; Written by Claude 2026-06-06 
  (defun my/org-to-markdown-clipboard ()
    "Export org region (or buffer) to Markdown and copy to clipboard.
  With no active region, exports the whole buffer."
    (interactive)
    (require 'ox-md)
    (let* ((text (if (use-region-p)
                     (buffer-substring-no-properties (region-beginning) (region-end))
                   (buffer-substring-no-properties (point-min) (point-max))))
           (md (org-export-string-as text 'md t '(:with-toc nil
                                                  :with-author nil
                                                  :with-date nil
                                                  :with-title nil))))
      (kill-new md)
      (message "Markdown copied (%d chars)" (length md))))
  
  (with-eval-after-load 'org
    (define-key org-mode-map (kbd "C-c m") #'my/org-to-markdown-clipboard))

Sometimes I daydream that the end goal demo would be to set one up in a VM and let a sort of ransomware lose in it, and see if the agent can identify what’s going on and react in time.

But for now I’m fighting Apple notarization to enable local notifications on macOS.

[0]: https://github.com/lightless-labs/descartes

Hister is a full text indexer for websites and local files which automatically saves all the visited pages rendered by your browser. It provides a flexible web (and terminal) search interface with offline result previews & detailed query language to explore collected content or quickly fall back to traditional search engines.

It can provide a privacy-respecting search experience for serving “recall” type searches where users retrieve previously visited content, but falls short in “discovery” type searches (yet).

Much kudos. I hope more people discover how powerful even a local search index of previously visited content can be. And I hope more people can build large indexes as well, so we’re not just relying on Brave & Mojeek & Marginalia (and EUSP) to rescue us for the fallback discovery searches.

https://github.com/pettijohn/corsair-ai-workstation-performa…

Later I find the technique I developed to instantly load arbitrary large CSV files can be generalized to work with any format, with an incremental parser combinator. This means the tool can read from not only files, but any stream-oriented sources like a pipe.

I did used AI in development but it didn’t speed up the process very much, as I found a lot of time was spent on the deign of an intuitive and consistent UX. The project is still not very production ready, but in case anyone is interested: https://github.com/Verticalysis/Hitomi

https://gitlab.com/grepular/foxcage – Runs Firefox inside podman to isolate it from the host. Has some interesting features that I wanted and nothing else gave me.

https://gitlab.com/grepular/claude-sandbox – Yet another Claude sandbox. Runs it inside podman again. Has a pretty powerful proxy system for securing your credentials.

Currently working on a tool for sanitising email. Will be blogging it up at https://www.grepular.com/blog/ when it’s ready for others to use. Does things like applying policies to html/svg/calendar/vcard parts to whitelist or blacklist tags/attributes/css/url schemas, clean URLs, fetch remote content at delivery time and attaching to the email to prevent tracking, pgp and smime auto encryption/decryption and a million other features.

Most recently, though, is a basic python CLI/Flask app that makes it point-click to manipulate the route table and dnsmasq settings on a raspberry pi. eth0 on the pi goes to LAN and put a USB ethernet attached to a switch and you now have a pretty powerful IoT/Untrusted device inspection environment.

One click to change the DHCP settings offered to the device, run a pcap, allow/deny the device access to certain services or NAT them elsewhere as needed. Straight forward DNS adjustments that can be applied per device and now that MITM-Proxy has a python API… it’s pretty straight forward to also peep inside of SSL protected things.

Various MCPs for above.

A “remote claude code server”, that gives project level overview and lets me run projects / develop on my home server rather than locally through my laptop. Supports ssh as well as a web UI (projects in a list, shell rendered using https://xtermjs.org/, with a tile overview when working on multiple projects to watch for turn ends.

Similar to above, I have a local version that auto launches a new project scoped podman container, passess through the work directory, installs CC/Codex/Grok into it and passess through the auth / config for each agent. Then dumps you into that shell with aliases to map each agent to that agent with a few special env flags to disable permission prompts, so claude = `claude –dangerously-bypass-permissions`.

An extensive MCP for Obsidian that gives agents access to use a lot of the more advanced Obsidian functionality, such as suggesting and installing plugins / configs / etc.

It’s helped some of my daily productivity, but I still prefer to get my hands dirty with code most of the time rather than full prompt it.

Or were you only asking about digital tools? I haven’t really made any of those. Making physical tools feels much more satisfying these days.

I made that realization last year and since then it’s just been random project after random project each one requiring me to discover a new tool or method to do some aspect of the project “properly”. I’ll never be a plumber or electrician professionally but it’s so rewarding to start from zero and learn something new that is tangible in the real world. That’s the one AI use case I’ve walked away from feeling like I actually learned something.

Im slowly trying to extricate myself by cooking more from home only from local farmers and what I can grow from home (so far only one cucumber). After all, can you really build everything else if your own body molecules are being replaced by low quality things made by others?

I’ll get around to 100% at some point before I die or I wont care anymore since i’ll be dead: one of those outcomes is inevitable.

For reddit there used to be the json endpoints that you could just fetch, and you can batch your subreddits, so its nice end easy. They have just killed those…old.reddit still works, but i fear like the days are numbered there as well.

Deepseek v4 pro does a pretty good job of actually adhering to the word restrictions.

Most language learning content is “slop” anyway — so might as well generate slop that’s at least a little interesting.

Normal browsers have built-in dev tools – this has built-in design tools. so I can visit my app, open up a surrounding canvas, pull fragments into the canvas, do some design-ish stuff, and merge it back into code. All in the same UI. It was cool enough that I’m going to release it, but for now it’s very useful for myself.

https://matry.design/

It creates its own copy of your workdir for the agent to play in, and then you pull changes out ala git diffs or commits.

It’s a MASSIVE time saver, and I use it as my daily driver.

https://github.com/kstenerud/yoloai

I also build a ton of household glue stuff; I was never really passionate enough about the whole “homeserver” thing to spend the effort in going beyond basic video recording for my security system, but now I have all of my local-only home automation stuff wired together, mostly into HomeKit, and have been able to ditch a ton of cloud services.

https://github.com/hale-lang/hale

Few tools:

1) a combination of Python scraper and Claude skill to help family members find job by matching jobs to resume, to rank best fits

2) similar to above, but for stock data and financial news to identify movers and why they moved and see if anything is interesting.

3) a couple of attempts to import EPIC medical data from hospital into an offline app. Needs more work, data export from EPIC is crappy and a mix of images, pdfs, text, HTML and .jsonb files. Not useful at the moment

4) an application that downloads stock market data to run 15-20 strategies and back testing to identify stocks that match multiple and then run sentiment analysis on news feeds. Interesting, but semi useful. Needs lot more work.

– Custom off-brand version of Pangolin

– Dashboard with beautiful UI for parsing traefik logs with database, filters, map and various integrations and statistics

– Samsung SmartThings Volume Control for Soundbar in Windows 11 native style

– Android App with good UI which serves as remote for switching display output modes for PC for movie night / gaming night with various toggles and for remote game streaming

– Many little one-prompt apps which run in background for QoL

– Reverse Engineering with IDA became a walk in a park

Most of the tools I write now are bridges to various SaaS products that have APIs but no CLIs.

[0] Yes this is a plea, if anyone has the good stuff

I have a small RPI acting as my homelab pihole and dns so what better than to run the management UI on?! So I wrote a small bun management plane, nothing fancy, just a react app with user auth + openidconnect for those that like that stuff. From there, you have compute pool (empty at the moment because it requires a deployed agent). I added the ability to directly ssh into a machine, install the “agent” with privilege so it can manage docker, and the agent talks back to the management plane over websockets. A keep alive / health / status / resource packet every 15 seconds. Streams if you are looking at logs or accessing a container. I used Codex for most of this work but defined the protocol and everything upfront using protobuf (even though it’s websockets). It helped with the “vision” and keeping the agent like Codex on the rails through completion.

Once you have a pool (agents installed on your N number of linux machines), you can deploy apps (which are my way of saying, a container with a namespace) or you can deploy agents (which is my agent, custom made for this) that are assigned to a project. I decided Org structures are a great way to delegate workloads so that’s how they are modeled. Projects provide the git repo, the docker registry for images and storage of artifacts, as well as the history of all the prompts the agents have done in the project. Useful if you want to go back and search through |thinking| tags to figure out the reasoning behind a decision.

All of this was built in like maybe a month with Codex initially, until my agent was up to the task of coding w/ an endpoint configured (OpenAI API initially, now, NVidia DGX Sparks). What really works well is the delegation. The agent’s have a webui that is exposed via the project urls so you can interact with the “scrum masters” of each project. They also share a stream if they are on the same project (but different subprojects).

I too wish there was more information on this but I didn’t keep the lack of it from stopping me experimenting and finding what works. I came from the Mesos/DCOS era where you stop thinking about the metal and think in pools of resources. It’s a distributed systems problem.

I realistically probably would have only saved myself less than an hour of crafting those expressions if the tool had already existed (with this level of detail, there are lots of many simpler ones already for it), but I would have spent a solid 40-50 hours of bouncing between manually crafting and writing detailed instructions to direct the agents to get this tool there.

[0] https://jsonpath101.com/

https://smartdomainfinder.com/

It uses an LLM to generate domain name alternatives that are relevant to your keywords, then checks whether any of those alternatives (in several TLDs) are available to be registered.

Warning: It’s still a bit glitchy as I haven’t fixed all the issues yet. It uses LLMs, but it’s not a vibe-coded app itself. If it seems to be stuck while finding domain names, just refresh the page.

Then, I got bored because they seem to be bad beyond certain complexities. But around Christmas last year, things improved a lot, and I’m getting confident building real ones. In the mid of these, I also got an offer to work with the [pre]sales/GTM team of a large company. So, I have been building working prototypes of bits and pieces of boring enterprise business around the world and have been racking in, if not billions, but very close to it in sales pipeline in about two months. (I did that 1B token in a week thing.) I’m sure the business and sales team will be able to convert 20% to 30% of that in the coming months. I also pitch and presented my work directly to customers and they are coming for more. So, it has been fun.

Lastly, I really wanted to scratch an itch I had for a while—build a Static Site Builder. But I ended up buildig it to be a documentation tool for TypeScript and JavaScript. It can be used as an auto-detect and let it build alongside front-end projects, make it a hybrid so you can add human-written documentation too or just build a Jekyll-esque static site.

O’Vellum is a 3-in-1 documentation tool. https://ovellum.oss.oinam.com

The work silencer/breaker is at https://void.oinam.com

The bubble popper that I re-created which my daughter loves https://brajeshwar.com/2025/bubble-wrap/

1. family tree based on wikitree format. Transcribe records, verify/edit, then incorporate them into the tree with full citations and biographies. This one is the big one. It includes a tree browser and best genealogical practices.

2. Pool Math replacement. Log pool chemistry tests to markdown files and suggest the right amount of chemicals to balance.

3. Calorie counter. Log calories to a markdown file, look up foods and amounts in online databases, sync with garmin connect for exercise calories.

All of these are written with AI but also are interacting with pi and telegram, mostly using deepseek v4 flash.

My own Alfred replacement is actually better for me, it’s tailored to exactly how I want to use an app launcher / shortcut tool.

OneNote to markdown/obsidian canvas converter. It did that using interop api to read the actual XML of the onenote files.

Work time tracker as 1px line on edge of monitor. Shows thin line at the edge of the display which fills up based on what i am doing.

Plaintext bookmark chrome extension that save links to local markdown file, Dynalist, Workflowy, Github Gist and import export between them. Was originally for Dynalist when AI couldn’t do much 2-3 years ago. Recently added these other end points. [2]

A heart rate monitor with finger on camera. It’s bit crappy though. Had to make it because many trackers, including google fit, couldn’t detect 200bpm. https://github.com/SMUsamaShah/heart-rate

[1]: https://github.com/SMUsamaShah/LookupChatGPT/tree/claude/fix…

[2]: https://github.com/SMUsamaShah/plainmark

I am going to develop the next version TermOnHost, which will let you connect to all kinds of hosts (Mac, Windows, Linux, or any Linux embedded system)
And your hosts can connect to each other.

I made it to deal with internet censorship in the UK, where different sites have different optimal exit jurisdictions, and most sites work fine so I can avoid the extra hops where possible.

It also works well for video streaming sites with geofencing, since the geofence itself is usually implemented in the frontend rather than the CDN. So only the frontend traffic needs to be proxied, while the bulk CDN traffic doesn’t need proxying at all.

Socks5 is the ideal layer for hostname-based routing, since the proxy can see DNS names without needing to sniff TLS SNI (which would be incompatible with ESNI/ECH etc.)

iirc it was basically all done in a single prompt, and I’ve been using it ever since. The only issue I’ve encountered is with WebRTC not working properly with some services. (Presumably it breaks the NAT holepunching process or something, I never diagnosed it)

Another project that isn’t quite finished is a “universal” web video downloader that works by shimming the MSE APIs and remuxing the streamed segments back into a regular video file. The idea is that if you can watch it, you can save it – including but not limited to youtube videos. I started this one pre-AI but AI was a huge help with the container format wrangling.

https://mithraeum.studio – local first agent and editor in C, also a few models on HF (mainly jsut qwen wrapped atm but working on from scratch)
https://fieldopt.dev – SaaS for dispatching jobs to the field (technicians, trades, delivery, etc.)
https://github.com/zblauser/ytcli – youtube music from the terminal in zig (ps it’s free, no sub needed)

It still needs a bunch of polish, but I use it a few times a week.

https://github.com/delecti/toof

Since I live far away from family I also added an online game so I could play with them or show them what I was making more concretely.

I’ve cut some jigsaw puzzles that it made, but without access to an uv printer or a laser cutter that works reliably it’s been challenging to actually make them

A tool that checks for new movie and tv releases, looks up ratings to see if they are worth adding to my plex server (see above about services I’m running), and then finds the magnet link and downloads them. But will only do so if my VPN is connected.

A tool that allows me to quickly build out paintball fields using my STLs of bunkers that I made, and export the full field layout as a single STL for quick painting, slicing, and printing.

Pugneum, my static site generator based on pug/jade. Technically made many years before LLMs, but AI is fully maintaining it now so I think it counts. It’s gotten to the point I believe it’s superior to markdown.

– Meetup alert for meetups that match specific topics

– A daily journal that transforms entries into chibi-style cartoons

– A cashflow forecast our stupid accounting software can’t do on its own

– DIY service monitoring for a ragged collection of docker containers, cron tasks, scripts and various others

https://github.com/ityonemo/otzel

– Spector, a bare-bones CQRS library for elixir that composes extremely well with Otzel:

https://spector.hexdocs.pm/Spector.html

– nanodrop, an elixir library that interfaces with nanodrop spectrophotometers:

https://nanodrop.hexdocs.pm/Nanodrop.html

– opengenepool, a web-based dna editing tool (technically I started this one 11 years ago):

https://opengenepool.vidalalabs.com/
https://github.com/vidala-labs/opengenepool

– a proprietary camera library that communicates with industrial-grade digital cameras.

– a full on self-hosted lab management system (journal articles, obsidian-like notes, lab notebook, kanban, embedded dna editor, LIMS), obviously this builds on all of the above items

I’ve done a lot of little things in Emacs since. Just minor things to improve my workflows or build up Chief of Staff type information flows.

The biggest unblock remains the tools/scripts/skills for documentation (started with Notion, network now sits on Obsidian for read/write).

https://github.com/Opfour/coeus-ci – Named after Coeus (SEE-us), the 100 eyed Greek Titan of the inquisitive mind — whose name literally means “querying.” CI stands for Competitive Intelligence. A business intelligence OSINT tool that builds company profiles from free public data sources. Give it a domain — get back a scored report covering stability, growth, tech maturity, financial health, security posture, and transparency.

https://github.com/Opfour/op4 – Op4 is a terminal-based encrypted messaging application written in Rust. It provides end-to-end encrypted private messaging with post-quantum cryptography, routed entirely through the Tor network so that neither the content of your messages nor your IP address is exposed to anyone — not even the person you are talking to.

Spartan (Private) – Open-source safety app for women. Community-based emergency response.

AATR – (Private) Catering unified platform: events dashboard, pack lists, and staff management

https://github.com/Opfour/thelinuxreport.com – Linux news and information aggregator.

God I love this stuff!

(edit: I also have about 6 more projects I am working on locally not yet uploaded to GitHub)

This was inspired by a karpathy tweet [0] and the prototype created using another tool of mine: The LLM Plugin Generator plugin (essentially a curated collection of plugins for simonws llm cli as a few-shot prompt)

The llm-model-gateway companion plugin lets you serve models from the LLM cli as a an openai API. This allows you to use saved consortiums in your various clients as if they where a regular model. Bringing massive parallel reasoning to any workflow.

It occured to me at some time that an collection of parallel LLMs was not really a consortium. A consortium is a group of organizations. A group of groups. To rectify this I added for actual consortiums, where each member of an llm-consortium can itself be a consortium of models. e.g.

llm consortium save cns-glm-n3 -m glm-5.1 -n 3 –arbiter mercury-2

llm consortium save cns-k2-n3 -m kimi-k2.6:3 –arbiter mercury-2

llm consortium save cns-meta-glm-k2 -m cns-k2-n3 -m cns-glm-n3 –arbiter cns-k2-n3

Yes, even the arbiter/judge can be comprised of a consortium of models, bringing parallel reasoning to the task of judging parallel reasoning chains.

Consortiums can also now contain groups of specialists. These custom user-defined expert characters address the prompt from a different perspective. And a Westworld style Attribute matrix can be randomized to inject some more entropy into the process.

[0]https://xcancel.com/karpathy/status/1870692546969735361

Some other llm plugins I vibe coded:

classifai
generates labels with approximate confidence derived from logprobs

llm-alias-options
saves inference parameters such as reasoning effort with a model alias. (good for setting the provider in openrouter or creating a consortium of high temperature models)

llm-prompt-json
adds a –json flag to return the llm logs object (good for getting conversion_id, or reasoning output in scripts)

llm-jina adds support for all jina AI specialised models and tools like web fetching, embedding and reranking.

* Auto-Birthday – if you have a contact in your android contacts that has both a mobile number and a birthday in their contact info, you can choose to send them an automatic “Happy Birthday” message on their birthday at a specific time. Can do it with hundreds of contacts. Doesn’t use hardly any battery or resources.

* Wrecker – stupid simple “throw a ball at a tower of bricks and try to clear the board” game. High score tables. Made in unity. High battery when in use, No battery use when not playing. Will use internet for high score data.

* GeoNote – Create Geo-fences to generate a notification when you enter a location with your custom text in the notification. My wife is always telling me, “Next time we’re here, remind me to only order one piece of toast” or something like that, so I make a note, it pops up the next time we’re there and we’re both happy. Notes are stored locally. No internet access required. Uses Geo-Fencing which is more battery-friendly than always-on GPS access.

All my apps are free, very privacy-focused and as battery-friendly as possible.

No information leaves your device (other than the high score data in Wrecker).

You have to side-load my apps though. I’m not putting them on the Google Play Store. They’re so annoying to deal with! OMG

Nothing says “AI enthusiast” more than automating away social interaction.

It probably should message YOU rather than the person who’s birthday it is, so you can send something personal.

Also coming up, automated wedding/funeral attendance by your personal humanoid robot designed to look and sound like you.

We already have that. It’s called a calendar app.

Tuber[0] – this is my favorite, use it multiple times a week. It’s just a little CLI wrapper around yt-dlp for my most common use cases – downloading the video, or the audio, or the subs. And then, if you’ve got the Claude CLI installed, it can also shoot the subs through Claude for a summary. I use it all the time, it’s a great little thing!

Scrapio[1] – this is really specific but I was so pleased with how it turned out. You give it a list of “hacks” (“mods” for Super Mario World) and it goes out to SMWCentral, grabs each of the patch files, and patches a clean ROM. I think I only used it twice but it was just a nice way to chew through a list of hacks and get a few ROMs ready, made quick work of something that would have otherwise taken a bunch of annoying schlep work.

Lotus Eater[2] – calling this a tool is a bit undersell, but I’m still really pleased with it. It’s a fan site for jamtronica greats Lotus that scrapes Nugs.net for setlist data and lets you do some mildly interesting analysis on things like song frequency and co-occurrence. Also has a per-user “shows I’ve attended” thing, Setlist Bingo. It’s been fun to hack on.

Lastly, less a tool, more just a toy: last week Google released their Magenta model for doing live music generation. I thought it was really neat, and it’s open source, so I opened it up with Claude, and after a few passes and some extremely annoying toolchain issues, I was able to add a spectrograph which does key / chord analysis to the “Collider” app, so you get a live readout of “what the band is playing” and you can pull out your guitar or whatever and join the jam with some info at your disposal. It’s the kind of thing that would have taken way too much effort to be worthwhile in the past, but with AI, it’s a really neat result of a fun night of weekend hacking. See the README I added in my fork for a screenshot:[3]

[0]: https://github.com/epiccoleman/tuber

[1]: https://github.com/epiccoleman/scrapio

[2]: lotuseater.epiccoleman.com

[3]: https://github.com/epiccoleman/magenta-realtime/tree/eric-mo…

Highlights are that it completely free, no login required and works offline (once you “downloaded”/cached some files the first time around).

This one generates maps from OpenStreetMap data + some custom curated info in YAML: https://github.com/c0nsumer/trailmaps.app-map-generator

This one converts a basic chunk of OpenStreetMap data to an SVG so I can mark it up (by hand) in Adobe Illustrator to make specifically-styled print/PDF maps, such as what get installed at trailheads: https://github.com/c0nsumer/osm_to_ai

This one takes GPS recorded rides and builds custom/personal heatmaps serving up the map tiles so I can use them in map editing software: https://github.com/c0nsumer/local-heatmap-tile-server

And all of this has been put together to make the custom, local, specific-use-case maps that are at https://trailmaps.app (which, via local curation, are overall better mobile/online maps than many of the bigger auto-generated systems such as Trailforks, Gaia, RideWithGPS, etc, for visualizing local systems).

It’s neat stuff where I understand all the inputs, outputs, and how most of it works, but AI tooling (Claude, mostly) has allowed me to bolt it together much faster than I would have writing it myself.

The idea came from using the Strava heatmap in JOSM to trace the proper location of mountain bike trails. I’m trying to use Strava less, and usually have ridden the trails enough myself before mapping them that I could use my own routes… So I figured why not have my own heatmap tile server?

It’s also cool to just look at.

I could take it a lot further with time boxing what’s displayed and whatnot, but generating the tiles is computationally expensive, so I just stuck with what I have for now. It meets the need.

I also built this site for educating potential customers and other privacy professionals about the increasing tempo of CCPA enforcement actions driving compliance: https://ccpa.world/enforcement

I could have probably coded this from scratch quicker considering that it took me two weeks to remove all of the hallucinated imaginary enforcement actions against real companies and also the citations to non-existent California law that the models kept injecting into my enforcement summaries.

most ambitious was browser extension to automate booking reservations since captcha and timing were critical.

swamp/evaporative cooler controller that monitors rate of change of relative humidity and sends RF signal to cooler to turn water on for x seconds to keep humidity lower than just leaving set to cool all the time. Does a great job but need to work on edge cases and ultimately replacing remote with my controller.

financial models for retirement planning

pen plotter gcode creator for old 3d printer to make labels.

food monitor to track what i ate with AI analysis based on symptoms recorded as well as interactive follow up questions

inventory app for electronic parts that now is inventory for all kinds of stuff like tools/plumbing etc that uses photo/ai to fill in data.

Jira Chrome Extension to add some notes and links to dashboard pages that I wanted for ease of use.

Small application which takes a CSV and turns it into a Registered Server List for SSMS in order to keep my list of servers updated for queries across all our databases.

Honestly one of the good use cases for AI. Small low complexity scripts and tools for assistance is a great use case. I’m amazed at the folks that are doing huge monolith rewrites with Agents and such, but I’ve never had good results for that. Small time saving scripts gets me a much more direct return on investment.

– Converted invoicing to Typst (from LaTeX)

– Automation of blinds

– Automation of lights

– Python library to control lights

– ML tuning library

– ML feature interaction library

– Jupyter notebook slideshow interface

– Davinci Resolve Authomation

– Arduino eink bluetooth HR monitor

– Tons of small scripts

1. A dashboard that tracks my personal metrics (github, strava, todo completion, flossing)

2. A eink display for that dashboard

3. A realtime node graph that shows a codebase (and/or its diffs) in a way that I can visualize what functions call which, and under what conditions

4. A agent that automatically fills out government forms and creates invoices for my friends brewery based on the delivery notes in their google calendar.

Having worked with web facing teams there are always vastly different methods any individual uses to capture their feedback. If you or anyone you know on Mac that has 100s of screenshots on their desktop, this is aimed at bridging the gap.

Clipboards are optimized with context for LLM markdown ingestion and for use in work suites like Jira/Confluence.

Still fairly early, but I’ve been using the tool to help build the app itself which has been an enlightening experience.

The team behind Gel got acquired by Vercel and I already experienced falling in love with a dead database (RIP RethinkDB) so I decided to fork the concept to a TypeScript port with Svelte as the UI instead of React.

It’ll live at disc.sh in a few months. Early dogfooding is promising.

EDIT: Also forgot that I removed React from GraphiQL in favor of Svelte too. https://news.ycombinator.com/item?id=48044888

https://azriel.im/disposition/

The text editor has an LSP built in to guide you to what can be entered, but see the examples.

I wanted a way to have visual documentation that can show/hide detail, and be pure svg so that it can be pasted into sites without becoming pixelated.

Also supports animations to show interactions between hosts, which always gets messy when drawing a static diagram.

– small club website: https://www.kolibrinkpg.com

– ticketing system with Stripe payments and QR scanning at the door

– Instagram/media ingestion for the club site

– genealogy tool with GEDCOM import

– scripts for downloading/archiving public-domain film material

– playlist/library tooling for DJ use

– music collaboration/sync tool for Ableton projects

– normal work stuff in a much larger existing codebase

I have become a lot more strict about process after being burned a few times. Mostly: make the change small, be clear about what it is supposed to do, check the assumptions before coding, use tests/logging/manual checks as evidence, and don’t merge anything I can’t review and explain myself.

Among many others

Calibre web UI 2.0 to replace Calibre’s mediocre web interface. Used for browsing ebook catalog, searching and cataloging with a simple list feature.

Project Gutenberg local mirror UI to browse my local copy of Project Gutenberg books

A couple of MCP servers for self-hosted services to give access to OpenClaw. Currently working on a daily digest that Claw will generate that includes feeds from these: what news stories were popular in my feed reader, did my baseball team win, etc.

https://www.motormait.com/

Bc my version uses simple copy/paste rather than deeper OS integration, it works more reliably in the Claude Code terminal (has to do with active windows or cursors or something). And bc it uses local Whisper, I also find it transcribes technical words such as “git” more accurately.

Nothing technically challenging but practical for me.

After that I started writing opub.dev because even minimal success in recent oss showed me just how much has changed, and I’m worried about how expensive everything will get for maintainers.

So, now I’m trying to GIVE people compute so they can start building a helpful filter layer above their projects.

A remote image viewer to see screenshots in VMs.

A simple agent harness to drive spec to verification.

A YouTube video summarizer.

https://github.com/ozten – some public repos, but the majority are private repos

Somewhat related – I wish there was some local thing I could give my 100 holiday videos and it made something fun with the highlights to a specified duration.

1) Automatically editing out pauses 2) Making those TikTok-like captions

https://bedtimebookhelper.com/

After coming back from paternity leave, I found that my team had really leaned in to AI driven development. This project was half catching up and half attempting to solve the burn out from the repeated books my wife and I were experiencing.

I’ve also built a release notes app for my QA teams, a DORA metrics app, a thing to map UX journeys with Playwright, and a ton of games and stuff. AI got me back into enjoying building things again.

The final idea is to own all my data, but I’m still on it.

Pretty happy so far

I use it, and have given my students access to it too – they use it to help their revision.

The Dead Classroom Theory.

It wasn’t perfect, but it helped me feel confident in the final result.

https://mediaden.ca – iOS app for storing encrypted photos/videos on storage I (the user) exclusively owns, with zero servers, zero telemetry, and a host of other privacy related features.

But no honestly, unfortunately most tools I did for myself are not for hobbies but something that I needed for work… like this one (https://github.com/crmkit/crmkit) most recently.

It has “levels” of compilation, with EASY mode being about as easy as Ruby, and the compiler can present you with options to get that as strict & performant as Rust/Tokio.

I’m going to need at least a month to finish all the documentation, though.

– github clone + extras

– a stack (FILO) based task manager / TODO list

– a CAD kernel with Blender frontend (WIP)

– a minecraft mod that makes real terminal emulators in block form

– ^ that but in Godot + a terrible “game” world (WIP)

– a somewhat failed app organizing claude workspaces

– a somewhat failed attempt at a VM framework for MacOS

– a somewhat abandoned gmail clone

– a farmland pricing model + maps etc.

– partially reverse engineered VCDS device

– a likely novel fractal system I need to work on some math to publish

– NTSC transmitter/receiver in gnuradio for the artful corruption of video

– backend for iOS appstore handling of account/subscription things

– an RSS / Podcast reader

ive made some wallets, a incredible pair of ear muffs, and a bunch of key tags.

i keep being asked if im selling anything, and when i get the next piece together of building/buying an embroidery machine that can work on leather, i might

i still dont want to buy a proper fabric cad system, so im trying to figure out a minimal version for making glasses cases for everyone’s christmas gifts. its handy being able to draw inputs for claude, but its also nails-on-a-chalkboard

I wasn’t planning on posting it yet, so I’ll have to get you a thorough follow up, but in a nutshell it’s: a continuously running 448-concept space (philosophy, cognition, art, nature, math) that occasionally “crystallizes” a group of 4 concepts via Hebbian learning and stochastic noise. Those concepts get sent to the LLM with minimal guidance beyond some safety guardrails and encouragement to be creative. It has access to a sandbox to produce essays, stories, music, “art”, and small python scripts.
Self-updating memory system. Notes, essays, and artifacts can also be discussed with me through some outbox channels.

On top of that it’s got a separate academic philosopher + psychiatrist llm that critiques its work and has a regular cadence of “sessions” with it, as well as a research assistant bot who I talk to (but doesn’t interact with Sisuon) who has full project context and memory access. The sisuonspeaks site is a VERY abridged collection of Sisuon’s essays, along with analysis, commentary, forum posts, and a podcast…all created by, you guessed it, more LLMs.

Already have $180 ARR prebooked (the money that I used to pay for youtube music), looking forward for more.

if anyone has links for open-source self-hosted spotify/yt music replacement, I would gladly appreciate links

Github:
https://github.com/jantznick/youtube-spotify

It essentially uses youtube as the music source, I think I heard somewhere that playing through embedded videos skips ads but I’m not really sure, in all my time testing it I never noticed ads, but I’m also on premium so that may have been why.

by all means critique, I don’t know that I have a ton of time left for it and I’m sure there’s bugs here and there. I was having issues getting it to autoplay on desktop when the window itself wasn’t the active tab. I never really tried it on mobile.

I was trying to get some DB of artist/song info but doing that was proving to be complicated.

I collect song metadata from various places (genre, instruments, track credits, rating). I also scrape charts by year, genre etc.

Then I run an ETL job on the json data I have downloaded, pre-building queries for extremely fast lookup tables. This gets saved to Duckdb, which is used by my go web ui/api.

It’s very early days, and I only spend one or two hours a week on it, but right now it’s amazingly useful. It had roughly 80k song metadata. To preview the suggested songs I ended up building a very cut-down YouTube music player, except that the playing song has all the metadata right there, and everything is a link that can take you to the artist, composer, instrument, genre, album etc. It’s a great way to “wander through your collection”.

Unfortunately this is only useful to me, because I targeted the music I listen to.

Next step is to download lyrics and extract song meaning, keywords etc. Then use MusiCNN,
(or CLAP,OpenL3, HTSAT) to extract embeddings. Finally train my own model for
nearest-neighbor retrieval based on a mix of metadata, giving the user the ability to tune it on the fly.

Static site generator for my blog, or at least bits of it.

I also built a new web framework we use internally which is amazing. We might open source it soon. It has a postman clone that has a bunch of features I wanted. It really is the case that we can just build tools any time we want.

https://charleswiltgen.github.io/TagLib-Wasm/ – Also built for myself initially, I FOSS’d it because there was nothing like Mutagen for TypeScript/JavaScript runtimes. (I don’t dislike Python, but think it’s a bit of a mess.) This was my first serious project to leverage LLMs for coding.

https://pwascore.com/ – Built because I wanted to quantify how bad Safari was at PWAs. Learned that, objectively, Safari is as bad as PWAs as Firefox (which is to say, not terrible, and not to blame for why PWAs continue to be mostly-irrelevant).

basically trying to see what a vertically integrated agent looks like, where the agent has deep access inside a framework and it operates from within a framework, so like, instead of reading files, opening processes etc – it gets a bunch of framework specific runtime tools(logs are the easiest example)

But I dont use “AI” to make them

I use a code generator

I like to use the smallest possible “toolchain”, using the least possible resources, to build software tools

Ideally I want the tools to compile quickly on underpowered hardware

Its open source (https://github.com/micro/mu).

– I didn’t like that I can’t use my newsreader on my laptop and my phone as easily so I built https://github.com/mjc/nntp-proxy. that turned out to be really hard to benchmark once it got fast enough so I am working on an nntp benchmark tool https://github.com/mjc/nntpbench. both can do request queuing because the nntp RFC says servers have to accept as many requests as they can, and then process them in order. so if your client doesn’t do that, you can use more connections to the proxy and it will queue for you. it also routes stateless commands to whatever server is least-loaded, and will switch to stateful mode if your client needs it.

– I didn’t like how expensive AWS Transfer Family is, so I built this https://github.com/elixir-ssh/sftpd and then rewrote it in rust (alpha) https://github.com/mjc/sftp-s3-rs. this shook out a bunch of bugs in russh, which was fun.
– didn’t like that there’s no par2 implementation in rust so I built this https://github.com/mjc/par2rs (I’m too lazy to move to tape backup so it works pretty ok for dvd/bluray parity), unfinished but good enough for my use.
– same deal for 7zip in rust. https://github.com/mjc/r7z
– a medication tracker thing that uses claude/codex/copilot to scan the bottles and parse them as well as identify pills etc. works better than you’d think but I’m not planning on releasing it for a while.

fixed or fixing bugs in:
– exqlite (it should not crash anymore and should return busy a lot less often.)
– russh
– swift-nio-ssh (this might be why codex’s remote can’t connect to your ssh box) https://github.com/apple/swift-nio-ssh/pull/236
– NanoKVM (working on making the streaming for this a lot more fluid)

And the inverse as well, of course.

Runs on a raspberry pi that I was otherwise using to take backups periodically… has been working pretty good honestly.

I also built a program that fills/submits my time reports, and does the same for all of my subordinates – then signs them off… Saves everyone like 5 minutes if we remember to do it, or 12 minutes and frustration if we’re reminded by HR about it (which happens because who the hell cares about time reports?)

2. A shopping list app that allows me and my partner to coordinate on our shopping

3. A recipes app that includes AI scanning

4. A standalone home battery dashboard/app

5. A fuel prices app that is tailored for the closest fuel stations and is ad-free

6. A tool to draw classroom supervision maps for my partner (thrown away already, I didn’t want adware/bloatware so I built it, she used it, then I threw it away)

7. A quiz website, cos the one I used to play on was overrun by ads.

8. A time tracker that I’ll throw away at the end of the tax year

And more, and that’s just what I did for making my life easier, there are other more “enterprisey” things I am working on. They’re web apps that I add to my iphone desktop or run on otherwise junky old tablets or on TVs.

The point is that they do exactly what I want them to do instead of relying on downloaded apps that get me 80-90% of the way there, even if they’d be classified as “AI slop”. I know enough about security and caching that they aren’t full of holes and don’t kill upstream, but I don’t really care about the code, and it’s literally easier for me to build something new than to go to Google or an app store to find software that’s full of ads.

Built a meeting-intelligence pipeline that turns raw, error-prone transcripts into a structured, queryable knowledge base. Meetings get auto-transcribed by Krisp, whose speech recognition mangles the things I most need correct, like colleague names, customer names, internal product and architecture terms. I hand each transcript to Claude alongside a hand-built context document, and it works a fixed routine: read the context file, read the transcript, then reconcile every uncertain name or term against a master error table before drafting anything. Only the genuinely unresolvable handful surface as questions; everything else is corrected silently. Once I confirm those, it emits a cleanly formatted markdown summary in a manner I describe as a template: overview, topical notes, decisions, action items — and pushes the work items into Todoist so commitments don’t get lost.

What makes it more than transcription cleanup is the back end and the feedback loop. Each summary hits Obsidian with YAML frontmatter and live Dataview queries, so open action items and meeting metadata behave like a database rather than static notes. In Cowork the whole accumulated Obsidian folder becomes fully queryable rather than merely searchable — instead of grep-ing for a keyword, I can ask questions that reason across months of meetings (“what were Todd’s table-stakes asks, and has anything shipped against them”), with the model able to look across separate conversations. The other half is self-improvement: every clarification I resolve gets written back into the context document: its people directory, terminology glossary, and especially the ASR error table, so a garble I corrected once is corrected automatically from then on. Over time that one document has become a domain-tuned lens, and each meeting both draws on it and sharpens it, which is why the summaries keep getting tighter and need less of my intervention.

Beyond that: I use a Netatmo weather station which has a RESTful API (or sends to a cloud server that has one) – I pull that information (which I can see on the web and their apps) into my own VictoriaMetrics / Grafana set up on Kubernetes, via a Go app Claude built.

This app above was when I had my little aha moment: Netatmo’s OAuth is slightly broken (issues with the different tokens and refresh). But I’d written a dog-ugly app which managed to work a while ago. Claude kept trying and strugglign to understand why its OAuth code wasn’t working, and was asking me “are the credentials right?” etc. “Yup, I’m able to get data from my old app”, then it said “If you have the source code to that app, I can figure out what’s up”, it looked, identified the issue, tried to work around it and then we “agreed” – “Hey, this should work this way, but it doesn’t, and whether my old OAuth code should work or not, it does, so drop that in, and keep going”. “Great, let’s do that.”

Just a more helpful discord chat generally. It also gaslights you too!

Here is the tool: https://git.sr.ht/~asibahi/hoopoe

Currently working on a markdown search and wiki backed by Typesense, also has good web search, fetch, crawl. This will power my personal knowledge base system as an important step towards more leverage and better outcomes.

https://github.com/verdverm/gmd

Just a super minimalist thing where each day is one .txt file with the newest one at the top and a lazy loading scrolling list with every note going back 5 years

Supports CTRL + F searching, backups, and a bunch of other QoL features/macros

Its kind of a revolution that with agentic coding everyone can have their own hyperspecific customized apps

I find a phone call is more likely to get through to me than a reminder or alarm, which I can ignore or forget; an ordinary reminder is not as interactive.

Claude built it all and although there’s a script for it, I just set the reminders in an interactive Claude code session in the directory. (Like I’ll open a claude code session there and say “using the script in this directory, call me tomorrow at 7 a.m. with the message ‘dr’s appointment’.”

It works well for me.

Would have made them without UI with a bit more elbow grease invested in web-searching for some examples, maybe even a StackOverflow question.

Generally, I’m not a fan of LLMs and their social effects.

It’s a user daemon that runs on my machine and exposes a unix socket, and then a bunch of hooks in claude, zsh, vim, etc, that report directory and commands I’ve run and all that, pipes it to claude Haiku for summary, and then stores context in sqlite. It also exposes that data as MCP so I can use claude to say “hey what was I doing yesterday,” or any arbitrary time range.

I find that in the age of using AI agents, “Wtf was I working on yesterday” is an even harder thing to remember for me, so this helps me kind of track everything with a database that a) has AI summaries already and b) can be accessed by AI as well as a CLI.

I’m more than a mere typist; there’s a skill to getting a usable, useful app out of an AI.