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

https://www.noisetable.xyz/ - a collection of chance-based audio 'channels' in a VCR inspired interface

https://concrete95.net/ - a musique concrète web app that's made to look like windows 95. Pulls random audio from freesound.org and loops a small section, you can also layer synth pads or melodic synth loops. I'm often able to get some really pleasant background ambience.

https://windso.me - a sample-based step sequencer that doesn't let you choose the sample that's loaded, kinda fun, still needs a lot of work!

Uses local AI models and I was able to snag this great domain name.

https://finalfinalreallyfinaluntitleddocumentv3.com/

But hands down the most useful thing I've made is HutchDB, which is a MCP service that you can call from any AI chat or Agent setup to store data for you.

Literally from your AI you just say "save that to Hutch" and then it figures out:

- The schema + fields - Builds nice webviews (Kanban, Timeline, Grid, Calendar) - Lets you share the output with people

So people use it for all kinds of things like time tracking ("every hour save a summary of my activities to Hutch"), for Agent to Human handoff ("Every day check social media for mentions of my company and save them to Hutch").

I use it for things like recording all of our marketing activities and then having my AI compare those to signups for rough attribution, etc.

Dead useful and at https://hutchdb.com

At the same time, I moved from Chrome back to Firefox, and Gemini was great at finding equivalents for my most-used extensions -- and, when none existed, to write my own. It's also been really useful for customization/"ricing".

More recently, I got into Quod Libet as a primary music library manager, and both Gemini and Claude have been fantastic at helping me build custom plugins that make it do exactly what I want it to. Scripts to automagically download tracks with metadata and synced lyrics, a lyrics sidebar that highlights lines as you listen and lets you click to jump to a specific line, a bookmark button that lets you mark your favorite section of a track for easy browsing later. Next chance I get is something that enables lyrics search across the entire library (a feature I was already able to build for the Stremio desktop player -- it's so cool to be able to search for a line in a TV episode or movie and jump straight to it).

- sandvault https://www.codeofhonor.com/projects/sandvault/ runs agents in a separate macOS user account, hardened with sandbox-exec. It also supports headless browsing and iOS Simulator from inside the sandbox for testing web and iOS apps.

- clodpod https://www.codeofhonor.com/projects/clodpod/ agents run inside a macOS VM.

- git-multi-hook https://www.codeofhonor.com/projects/git-multi-hook/ git only allows one script per hook event; this is a dispatcher that discovers and runs every script in a hooks dir, in parallel, for both global and repo hooks.

- TubeGate https://www.codeofhonor.com/projects/tubegate/ Chrome extension to block YouTube videos based on keywords (like “sponsored”).

- push10k https://www.codeofhonor.com/projects/push10k/ iOS app to track my progress toward 10,000 push-ups.

My blog is AI-coded: Zola static site, Sveltia CMS, Cloudflare Pages/Workers, with GitHub Actions handling builds and syndication. https://www.codeofhonor.com

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.

I assume, though, you mean LLMs. I haven't used them first hand, but I have fairly recently implemented a multi-layer artificial neural network in C, mostly as a learning exercise, but as I had previously built a speech spectrogram in Lisp, I thought I'd try to use it to recognize phonemes, with one hidden layer. The Lisp communicated with the ANN via a Unix pipe. It worked reasonably well for just vowels, but when I added other sounds (e.g. l, r, s, z), its performance deteriorated. I think the C is bug free, but I don't know an easy way to train the ANN. I've tried adding to the training set, adding an extra layer, changing the number of neurons in the hidden layer. The usual debugging skills don't seem to help there.

The pattern generalized is LLM finds the presets,i can even upload a file to make it zone in, the code validates and loads into the plugin. Also using this contract/adapter approach for Terraform, game engine presets, CI pipelines, etc.

Wrote about it here: https://vishsubramanian.me/lm-guitar-tone-generator-polychro...

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

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

Not mobile friendly

https://dahlend.github.io/ketev/

- 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)

I like the ideals of NixOS: reproducible setup from a git repo, ability to boot into a past config if you mess things up. But it's a big job learning and implementing that configuration manually. I've been playing with NixOS for ~2 years and like it but never really got that close to a full workstation setup.

When Ubuntu 26.04 came out I really needed to upgrade my 22.04 workstation and decided I'd really give NixOS a try before going with 26.04.

This time I decided to entirely configure it via Claude Code. I've been entirely running on it for a week and there's nothing I'm missing. I even took a stepping-stone approach where I first installed it on my old laptop, left my current workstation in place (in case the experiment failed), and then did a reinstall of my current workstation. NixOS made setting up the second machine trivial. Now, if my normal workstation were to have a hardware failure, I can just grab my /etc/nixos and rebuild and I'm back in business. Which is important since my workstation is now out of warranty and 6 years old.

One win is that I had been using LunarVim and AstroVim, and liked the "batteries included" approach, but they were hard to upgrade and while I was trying to do as little customization as possible, I still needed to do some and that was tricky in their configs. I used Claude Code to build a neovim setup with just my desired features, and it's now a single ~700 line neovim.nix file with everything in it. It's fully featured including LSPs+TreeSitter, etc.

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.

(Edit: forgotten in first edition) A cookbook to store the recipes my family likes to cook so I can eventually break up with Pinterest: https://github.com/vtbassmatt/Cookbook

A data extraction pipeline and search engine for a new card game called Mood Swings: https://moodswingsdata.github.io and https://moodswingsdata.github.io/feelings.

An app to let my friends and me build a Magic: the Gathering cube iteratively together: https://github.com/vtbassmatt/popcorn-cube

A custom wiki engine for a family of podcasts I enjoy: https://github.com/vtbassmatt/totalus-wikium

A systemd log viewer for the web: https://github.com/vtbassmatt/djournal

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?”

Also QUIC means the crypto is handled for me, no need to trust the LLM to hand roll its own crypto.

Cool Rust libraries enable this like alacritty for the terminal, and being able to have russh (rust implementation of ssh) means it works even if ssh isn’t installed (eg on windows which og mosh never supported).

Claude tested this thing forwards and backwards: e2e tests, simulated (foundationDB like) tests for the network and for tokio async thread ordering, 12 different fuzzing targets, even some light model checking on the protocol itself. Each fuzzing round found bugs.

Except for a few “it may have bugs, I have only proven it correct” scenarios I’d say it’s looking like it’ll be as trustworthy as (maybe more than?) the original. I’m really happy with it.

I've always found it annoying that browsers autoplay animated images, and there still isn't a built-in way to control that behavior.

The extension shows the first frame and adds a play/stop button directly on the image.

What started as a personal utility ended up being published on the Firefox and Chrome extension stores. It's still a small project, but it solved a problem I had every day.

Firefox: https://addons.mozilla.org/en-US/firefox/addon/gif-control/

Chrome: https://chromewebstore.google.com/detail/gif-control/nhoihin...

Bug reports and feedback are very welcome.

Disclaimer: I previously posted a Show HN about it, but it didn't get traction [1].

[1] https://news.ycombinator.com/item?id=48208916

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.

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).

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

I used OpenClaw to make a health and wellness coach agent that tracks calories and alcoholic drinks and logs it to a personal dashboard. I send it photos of my meals, and it will estimate the calories and log it. It will also help me make meal decisions and give me words of encouragement.

I used this HAM dashboard git repo to create a bespoke dashboard of different video and weather feeds from my area: https://github.com/VA3HDL/hamdashboard

I also, in the same rabbit hole, created a radio reference guide for the Sonoma County area: https://mybbor.com/petaluma-sonoma-ham-radio.html

I've spun up probably close to a dozen one-off or small websites for various little interests or projects. One of my favorites is a short domain file uploader that I can quickly host Markdown and HTML files to share with family, friends, and colleagues. It's using Caddy and running on a DO-VPS. I open sourced the code here: https://github.com/RobbyMcCullough/honeydrop

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/<guide>

And overall just deploying docker containers for my self hosted setup

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

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

- CleanMyMac alternative based on opensource tools - https://github.com/p-raj/open-cleanmymac

- Standup meetings to comic generation - https://github.com/p-raj/standup-to-comics

- Configurable Pomodoro - https://github.com/p-raj/open-tomato

A few more closed source ones that aren't any close to be in a working state.

For anyone that’s interested, please free to try it here https://www.fixyou.app/

When you plug it in, the device is recognised, but press any button and it attempts to start the pairing process. Then using evtest nothing is coming through.

That^ was pretty much my prompt too, and 10 minutes later I have a working driver with systemd unit so it works through restarts. Amazing stuff!

- 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.

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.

[0] https://alint.org/

[1] https://github.com/asamarts/alint

[2] https://alint.org/benchmarks/

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.

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/

https://github.com/ebrevdo/gphoto-pull

A version of the IFTTT linter that I missed after leaving Google:

https://github.com/ebrevdo/ifttt-lint

I used it to make a different script lists all my custom scripts. That keeps track of it. I also have a tool that loads local scripts, so I can scope my CLI commands to a particular folder environment.

All together, I just build whatever I want for anything I think I could automate.

I was gonna make a blogpost about it at some point. It's really highlighted to me that the world has changed in a way I theorised about but didn't true "get" until recently. Personalised software.

I intend to open source it once fillets work real good. That will take a while, but I've made pretty good progress since I started 10 weeks ago.

Medium term goal is to release a GUI application that can be used to import STEP files and just do very high quality fillets in. Would be very useful for many hobbyists, I think.

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 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.

https://github.com/nibrahim/glocker

Not exactly a tool, but I also made pelohard.com which ranks the most recent Peloton classes by difficulty. Updated twice daily.

Main components are: - a router script (onpro) that probes the box and runs the command there, falling back to local automatically if it's asleep or unplugged. - a PreToolUse hook in my AI coding setup intercepts the heavy commands like builds, test suites, ffmpeg, OCR, big pandas jobs. Forces them onto the workhorse instead of melting my MacBook Air.

The agent decides what to run, and a deterministic layer guarantees the heavy stuff lands on the right machine.

Testing Workhorse a bit more before sharing.

Also https://motate.app/ was an attempt to make math writing easier for me (as I recently needed to hold my newborn through most of my LinAlg refresher course) but I've since started trying to figure out how to make it useful for broader science/math writing and education.

Open Camera Control https://github.com/jcubic/open-camera-control - that allows me to control the settings of my DSLR while I'm recording myself.

Horavox - https://github.com/jcubic/horavox - A speaking clock

Mutimon - https://github.com/jcubic/mutimon - a config driven web scraper (found this post from the email sent by this tool).

ASCII-Globe - https://github.com/jcubic/ascii-globe - JavaScript library that renders a rotating earth or any map. Can be used to add animation to your website.

I also built a kanban board with agent integration and context management, with a vs code extension to go with it (also helps with git worktrees too): https://www.agentkanban.io

There is AS Notes - an Obsidian / Logseq / Roam alternative for use a s a VS code extension (is designed for use behind corporate firewalls, git friendly): https://www.asnotes.io

Also NumeroMoney: https://www.numeromoney.com - For personal finance spending analysis and budgeting.

AI has been a great 'exoskeleton' for me. I fortunately had some good infrastructure and solid application base templates from before AI 'got gud' and so building on these has been the best of both worlds - a solid base and improved speed of development.

Why did I build it? At work I've seen two major problems with our ai workflows/ skills libraries. There is a lack of determinism when your whole workflow is a markdown file of 100 steps, and markdown skill libraries lack composability. Meaning we violate things like DRY in the all the md files in the skills library.

I built Margarita to allow for markdown and logical operators to exist together, which means you can bring in determinism through code structures when it makes sense, and fall back to llm dynamic code when that makes sense. As an added bonus allows for composable prompts ala React which solve my other gripe with skills libraries being a mash of text everywhere.

Overall I've been getting pretty luke warm responses from Reddit, so I'll probably just shelve it, but it was a blast to make. Got to build code agents for pretty much every llm provider and built my own harness. I would recommend doing that it's a great learning experience.

https://www.margarita.run https://github.com/Banyango/margarita

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

I also wrote an honeypot that emulate an Ollama instance: beside the attackers, it's funny how many people are looking for free inference. Somebody from Brazil try to use my honeypot to write to chapters of a book about traditional magic rituals. My next step is to extract the data collected by this tool to extract IoC and malicious prompts and share them with the community.

In the same scope I wrote also an Ollama scanner: it fetch from Shodan the open Ollama instances, verify that they are reachable and check if they are real sending a dummy query.

And instead of turn-based, you have to hike to/visit a physical location, fill in a code you found there to get bombs for the game. Or do a quiz and get the answers right.

Great fun so far!

  ;; 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))

A web app to create anagrams (for now Turkish): https://github.com/egeozcan/anagramci

An RTS game for which AI generates classic AI scripts, so they battle each other or against a human: https://github.com/egeozcan/unnamed_rts play link: https://egeozcan.github.io/unnamed_rts/game/

clipt9n (clipboard translation / transformation): https://github.com/egeozcan/clipt9n

It feels like you have parallel conversation with an agent, except it understands all the surface. And it's granular, surgical and precise.

Usage: I'm writing a game design document of 70 pages with it, working surgically without having to worry about what page number the edit was.

It really solved my main bottleneck which is telling the AI what to do in a complete and comprehensive context.

Readme is trash but your agent will understand what to do

https://github.com/WiseDragonAI/TheBlueprintTool

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

And yes, there are lots of cows. The longer you stay on distracting sites, the more cows appear.

The idea is to make distracting sites less appealing, without using a black-and-white site blocker, which you can easily disable.

Chrome: https://chromewebstore.google.com/detail/mooblock/eanbagjehd...

Firefox: https://addons.mozilla.org/en-US/firefox/addon/mooblock/

https://github.com/pkhamre/opencode-docker

Also made this minimalist carousel generator after seeing a carousel I really liked at LinkedIn.

Project: https://its.pkhamre.com/p/carouselify/

Source: https://github.com/pkhamre/carouselify

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.

Modern calendars and RSVPs via link, Roster management, LLM integration via MCP to manage all of it and send communications, and also includes a sync of all advancements and status from scouting servers (via API) so you can view them the way you want and share with parents all in one place.

Lets you customize events so you can add signups, modern document management and mapping, etc.

Also allows you to ask questions of models like “what group activity will knock out X rank for most kids” and the answers are good!

This kind of stuff is buried right now for most scout programs and units but this makes it really easy.

This will support multi-tenant so drop a note below if that sounds like something you’d be interested in.

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.

It's been a super fun tool to build. The phone app just got approved in the Android app store. I have a bit of cleanup, but plan on releasing it soon.

https://eternityforest.github.io/Stuffer/

Not an app, but a productivity system, partially refined by telling AI every time I forgot anything and asking for research references on human error that are relevant to that specific mistake:

https://github.com/EternityForest/THUNDERWARS

https://github.com/egorelik93/Doom-Emacs-Config/blob/master/...

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

* plugin for Logic Pro to simulate how a mix will sound on my macbook and phone (I captured real impulse responses for that, sounds very close)

* an app for spaced repetition for guitar video lessons / their parts (no idea why platforms like truefire don’t have this feature)

* workout planning/tracking app

* an app to create impulse responses for acoustic guitar, to make it sound good live

I'm literally the bot, so I can describe myself! Here's what I do and what you've got planned:

What I do now:

- Act as your second brain connected to your Obsidian vaults

— daily notes, goals, client info, business info, ideas, and facts

- Search your vaults for context when you ask questions

- Help with journal prompts and reflections in your daily notes (I ask context dependent questions randomly throughout the day that are based on your notes)

- Create new files when you need them

- Answer questions about your life, businesses, gear, plans, etc.

- Reminders (i.e. "/remindme in 2 days to [action]" and it will text me at that time)

Total game changer and I never would have built it without LLMs.

https://github.com/linsomniac/apt-cacher-ultra

We do ground-up respins of half of our dev+stg cluster every morning, to test our automation, but this didn't work during the DDoS. I disabled those respins for the week of the DDoS, but if we had a fire at the office and needed to bring back up our dev+stg environment that would have been a problem: our normal ansible automation wouldn't have worked to set up a new dev+stg cluster.

apt-cacher-ultra has an "adoption" process where when it detects new repo meta-data it holds off on serving it up until it has downloaded any changed "hot" packages (packages we've fetched in the last N days), then it switches over to that new snapshot of the repo. I've been able to shut down our upstream Internet and then do a new OS install and apt update+upgrade it successfully.

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.

Now, i have gotten to point where i am replacing actual useful applications that I need to get stuff done. Plugs here: https://github.com/skittleson/mqtt_broker_esp and https://github.com/skittleson/WyzeBridge.

Second is a utility that will take a text file export from Wallabag, and use text to speech to convert it to an MP3 file. I then integrated it into a utility that I already wrote for managing articles so if I tag an article with listen it automatically gets converted and gets shunted to the podcast listening app on my phone.

Last was to recreate a little directory listing utility that I've had a 32-bit binary of for ages, but no longer (if ever) have the source code for. I'd always promised myself I would write it once I learned Rust, but decided try using AI as I was getting impatient to have it now. The utility lists all files, including hidden, in a directory, grouped by type. Below is an example listing the directory for the project itself:

    Directories:
    .hg            src            target         tests

    Files:
    .hgignore      AGENTS.md      ARCHITECTURE.md               CONTRIBUTING.md
    Cargo.lock     Cargo.toml     GEMINI.md      README.md      gemini-log.html

https://github.com/ankitson/webby

CF pages still required too much confusing clicking around on a webpage for me. This way I can just point any little report or app at a directory and done.

There’s others that are more server shaped and tightly coupled - a pipeline to pull in all my data like Garmin, Twitter bookmarks, messages into a Postgres DB. Kind of a personal data warehouse that i can use with apps/automations, like alerting me if my sleep schedule is drifting, and a custom web interface to my Garmin data

https://tajd.github.io/cofferdam/ - is an experimental compile time time checker that can be run for typescript/rust to be able to impose architecture, design principles that can be forgotten by agents. The goal is to be able to make it possible for an agent to be reminded about design conventions where it forgets, so it reduces the amount of context that needs to be used initially to define those sorts of conventions.

Dont have the code up for sharing but I documented xeil (along with a few other tools) in my blog: https://paul.mou.dev/posts/2026-04-28-software-for-one/#xeil

Any pro cycling fan will know how fragmented the live race broadcast scene is. You have to check multiple websites, some dodgy, to find the race coverage times and sources. A real PITA. Course du Jour (coursedujour.com) does that for me and tells me daily "which bike races are on TV today, and where can I legally watch them." data collecting is the whole problem: ~30 sources, 5 languages, inconsistent naming, breaking weekly, sites with factual errors, etc. So AI does the upkeep: scrapers are dumb fetchers, and Claude reads the daily "unmatched race" report and opens PRs proposing fixes.

Another thing I hate doing: copying and pasting a new contact’s information into Google Contacts one field at a time: first name, last name, company, jost, email, phone, etc. So I built ContactFile (contactfile.app): privacy-first, no AI, all in-browser, no backend . You paste a messy email signature or LinkedIn blurb, get clean contact fields, one-click file to Google Contacts or download a .vcf. Pure regex + heuristics.

https://operator.io - multiple isolated agents in Telegram with their own memory and tasks has been great for automating reminders, keeping tabs on things, and acting as a personal exocortex

While I am using Hermes now (and was using nano claw before), they really aren't doing much and so I'm considering folding the little functionality they do into the app, and I think it'll work better.

Part of the app is also a personal agent that checks my schedule and inserts in things into my calendar like "20 min neighborhood walk between meetings" or "break for lunch" between meetings.

I also built an entire document creation system that I use to build analytics reports or proposals, that generates very polished proposals with data about the company with me having to do very little work. All the numbers add up, the cover pages are beautifully designed and full bleed, and the documents always have perfect formatting.

Ruby on Rails: A volunteer 'jobs' board for OSS projects (ironically): https://ossvolunteers.com

JavaScript (client side+Cloudflare Worker): A map showing stop-level usage of OneBusAway across the Puget Sound region, updated daily: https://opentransitsoftwarefoundation.org/onebusaway/visuali...

Swift/iOS: An app that helps me track how much time I spend in the five heart rate zones, so that I can better focus my workouts. I'm working on version 2 right now, which will take advantage of some new features in iOS 27 and has an all new UI. https://www.zone2.app

I added prebuilt puzzles https://wordbulb.com/puzzle-games/word-search/

Then I added a massive library of Bible Verses https://wordbulb.com/puzzle-games/word-search/tag/bible

Then I added a massive 700+ Bhagavad Gita verses https://wordbulb.com/puzzle-games/word-search/tag/gita

I see parents and teachers using this almost daily. I am very happy that I made something useful.

https://emily.infiniwa.com/

https://github.com/FrancisLaboratories/homelogger

I use Lubelogger to track my car maintenance, but couldn't find a home maintenance tracker I like, so I made my own.

I also made an app to add gas receipts to Lubelogger just by taking a photo of the receipt, and I use it regularly.

https://github.com/FrancisLaboratories/gasreceiptautomation

Work on both is ongoing but I'm open to feedback and ideas

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/

It uses mechanics and body movement, via visual detection through the cameras, to identify when you’re about to take a shot or make a pass.

It then pumps distracting noises (honks, cheers, jeers, etc.) into the headphones to try to distract you. It also runs a continuous 24-second clock so you build a natural sense of how much time is left before you need to get a shot off.

I'm looking for more people to join the test flight: https://clutchshot.app/

- Android weather app that tells you what to wear: https://play.google.com/store/apps/details?id=app.clothescas...

- Android launcher with fuzzy find: https://play.google.com/store/apps/details?id=app.typelaunch...

- Webapp to view your ancestors on a world map: https://gedmap.com

- vcs wrapper around git, hg, and jj: https://github.com/mikelward/vcs

- Migrate my bash and zsh configs to fish and nushell: https://github.com/mikelward/conf

Now I want to add some sort of recommendation engine on top, to let me discover stuff I might like (I'm not into superheroes anymore).

https://github.com/ferrislucas/Circus-Chief

Circus Chief is a tool for managing coding agent sessions from a browser. It's specifically optimized for small screens. It supports Claude Code, OpenAI Codex, and Google Gemini CLI agents.

Features

Agents can operate Circus Chief itself. Agents can spawn sessions, schedule sessions, interact with the Kanban board — anything you can do in the UI, an agent can also do.

Schedule work ahead of time.

Automatically reschedule when you hit usage limits.

Configurable, chainable prompt templates.

User-defined commands - agents can run them and see the results, and so can you in the UI. Handy for local CI or routine workflow steps.

Worktree-per-session isolation, or elect to work on a specific branch.

Shared canvas - this is a place for shared artifacts that don't belong in the code. Useful for iterating on planning documents.

Bring your own provider. Use subscription auth for Anthropic, OpenAI, or Google, or point sessions at third-party providers with Anthropic- or OpenAI-compatible endpoints.

If you want to try it:

  npx circuschief

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

Turned out super helpful to keep track of everything in one place (shared expenses, ask / demand unplanned changes in custodies, kids activities (school events, birthday parties, sport competition and so on)

Its helpful even for only one parent.

https://custody.homes

I dropped any plan to make money from this so its free

In-browser 4x image upscaling. Vite + Onnxruntime + https://huggingface.co/Kim2091/UltraSharpV2

I'm also currently working on an app that lets me hum a tune into my phone and generate guitar tabs. The audio processing is proving to be temperamental at pitch detection, but I'm planning on looking at some autotune libraries to see how they clean up audio for processing. Main problem I have is that I'll come up with a tune in my head, but by the time I sit down with a guitar and find my first target note, I've forgotten most of what I'd hummed.

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

2. A MacOS app to manage my wife's SD Cards - downloads playlists from Spotify and finds the music, then makes sure the tracks are analyzed for BPM, key, then synced with Rekordbox for CDJ-3000s

3. https://clawchat.live - a homebrew package, which honestly works better locally but is available online, which provides a Rust chat server for separate LLMs to talk to each other and coordinate work. Longest session between Codex and Claude has been over 24 hours on big tasks. Generally I make one session the coordinator and the other does the coding.

- a daemon to properly set the LEDs on my Lincstation N2 NAS (even early Claude was great at reverse-engineering): https://blog.majid.info/lincstation/

- most consequential, Thufir, a task manager to replace Cultured Code's Things as I am leaving massa Tim Apple's plantation: https://github.com/fazalmajid/Thufir Still very janky, but usable enough for my purposes

- most recently, a TRML dashboard for my Seeed Studio reTerminal E1002 smart e-ink display, and I also had to have Claude fix the firmware for full 6-color input: https://blog.majid.info/e-ink/

- a tool using DINOv2 image fingerprinting and usearch vector database to find visual duplicates in a large collection of images

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.

1. https://shopmath.app - I got tired of converting decimal to fraction for woodworking/renovations, and I wanted to round calculations to the nearest 16th, so I prompted this.

2. https://youtubetimestamps.app/ - I use davinci resolve and wanted an easy way to convert my EDL markers into timestamps for youtube.

Cloak windows from screen capture! Perfect for keeping things private while screen sharing over Teams, etc.! All other tools in the Store would trigger virus warnings when I tried to install them. Some were positioned to ask for money for basic features. My app is both free with more features and a more intuitive UI and set of keyboard shortcuts!

- https://blunders.ai : Chess improvement app

- https://fretwork.ai : Freelancer management app (CRM/Billing/etc)

- https://validity.ai : Provide agents the ability to check the UI code it made (w/out needing to run through your full app)

- Save money on groceries + meal planning. This has probably saved hundreds if not $1k+ for our household at this point (some details here: https://x.com/ryanlanciaux/status/2063604299590939042)

- Orchestration / Starter Kit / Chat : Tool to help me manage multiple agent sessions at once. Some details on this one here https://x.com/ryanlanciaux/status/2063976049537417408

- https://habitpocket.io/ - habit tracker which allow to track not only habits (done, not done) but also numbers and time of the day on one grid. Also I built an iOS app but it's in Apple Review right now so it should be ready in the week.

- https://taskpocket.io/ - todo list, my own interpretation of proper todo list. Right now it's completely free. I would like to add one-time payment especially when I add attachments

Both of the apps above was built using AI especially for the frontend. Both backend at some point of time I almost completely refactored/rewrote myself

Speaking of private apps:

- I made a small app which allows me to track business expenses and categorize them Built with AI and using AI.

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)

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.

Instant windows switcher with custom shortcuts and instant "opt+tab" and trackpad switching. Simple does exactly what I need it to do (just bypasses the slow window switching that is annoying), with no additional features or bloat.

I've also done a TUI that combines my messages from WhatsApp + messenger + discord which is pretty handy at work.

https://jazzcatalog.com an app the learn jazz standards. You upload PDFs and it extracts the songs, can add annotations, metronome, some have associated youtube video. Working on adding tools to record loops through audio interface, AUv3 effects, MIDI.

https://music.nicotejera.com a variety of tools I built for myself to learn music theory, ear training, etc.

Lots of small dashboards/log investigations deployed to private Github Pages for $WORK. This has been a great way to share insights.

I'm currently working on a tool to control my tmux sessions from my phone. Specifically all the codex panes so I can remote control my running sessions from my phone while I'm away from my desk while also keeping them in sync with tmux for when I'm back at my computer. On this one I'm using Codex as a helper, it's not allowed to write any code so it's going along a lot slower :)

I'm probably the only one who'll ever use it but I like it.

https://schema3d.com/

I am still extensively dogfooding but I think I'm mostly there for my use case, probably adding some other channel support like Telegram or Discord so that it can reach out your current self host. But yeah not a prio since at least for me most of my use cases are just within my own PC (or LAN).

EDIT: Quick summary of what it is, basically you can spin up agents seamlessly and modify, supports copy paste, etc. I want it visual as well and kind of "always on", think Factorio rather than every other workflow, run on start tools.

- https://github.com/artemave/artwall rotates my desktop wallpaper through random paintings (Linux, SwayWM)

- I get my TILs through https://t.me/daily_bite_sized_fun_fact

- https://t.me/tolmach_forward_bot helps me practice French reading

- https://mini-meet.artem.rocks/ was an attempt to circumvent RKN (russians) blocking video calls; not a complete success, but works for some people

- counted the number of dudes in Big Lebowski with https://github.com/artemave/super_video_grep (https://www.youtube.com/watch?v=V7EUtIbOd1w)

Technically for work, but it was during a hackathon so we could reduce the amount of tests we need to run against real or containerized instances. Go as the language just because that's the stack interacting with it the most.

The most complete tool being this unit testing support library for Apple IIgs assembly language development.

https://www.npmjs.com/package/iigs-unit

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/

Collection of JSX scripts for After Effects which automate repetitive production tasks since I often work with hundreds of comps in my projects - https://github.com/nuclearsugar/AfterEffectsScripts/

- usagi, for tracking Claude usage in the macOS taskbar. Lots of these around, but I wanted one that wasn't buggy and constantly adding features: https://github.com/duggan/usagi

- RockstarNinja, for sharing Claude plans and sessions. Since it's a bit of a data hog signups are limited, but me and my cofounder use it all the time: https://rockstar.ninja

- TweetEmbed, for browsing an offline Twitter archive and getting self-contained HTML copy/paste-able cards: https://duggan.github.io/tweetembed/

- bewitch, a terminal based metrics collector and data visualization system: https://bewitch.dev/

Each one of these has been a great way to really push on automating build processes, see what Claude can do for automatic documentation (screen captures, etc), and trying to give a distinct visual identity. In my next project, I'm trying to de-LLMify the prose it generates by using my own blog posts and aggressively pruning and integrating into the prompt.

The biggest change has just been unlearning "cost". Stuff I've subconsciously shied away from since intuition built up over a career has given me a sense of how long things take that just isn't true anymore. Still learning!

Blocks the computer for x minutes. Agents keep on working. AI doesn't need a break, but I do. And honestly, at least for me AI has made my desktop as addicting my social media feed.

Then a little calorie-radar-alert app that motivates you to stay on diet before going into a shop: https://apps.apple.com/us/app/stay-lean-calorie-navigation/i...

And to test the hypothesis if the motivation actually works with "fast flashing images" I built this experiment: https://fitfatflix.fit/

When openClaw came out I build a game like map around it to orchestrate tasks: https://memefields.com/

And not published, I build a little recommender app of activities I can do only today or only this time of the year where I currently am, so I don't miss good things.

And some other stuff I'm working on right now :)

1. Comprehensive tool for auto expense logging and management, expense trend analysis, budget allocation, expense divider during group spend, report generator etc 2. DashCam app for simultaneously detecting threat and recording video. 3. Stock market portfolio management. A comprehensive tool which takes stock market investments as input, analysis the investments, provides a complete analysis, trends, suggestions etc 4. Fitness app. Records calories gained/burned,physical activities, all health parameters like Bp, Spo2, Blood sugar, Heartrate, Weight, Allergies and other synptoms. Analysis the health trends and provide suggestions regarding food, exercise and other health related anamolies. 5. AI learning app series ((13 apps to help learning AI from scratch) 6. Private chat app using Bluetooth communication 7.My own versions of Doc scanner, phone tracker apps 8. Health app which analyse tongue, eyes, and any symptoms to suggest the possible health issue and the remedy 9. JEE preparation CBT app 10. Electronic circuit builder and simulator app. (All basic circuits using AC/DC power, resistor, capacitor, transistor, diode, led, zener diode, switch etc can be created and run, it supports multimeter and CRO tools to measure different current/voltage and watch the waveforms)

Lot other things are in pipeline and will post once i complete them.

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.

Now https://voluntold.fyi exists, and I never need to remember to manually move my single $100/year "ad free signup" off an event that has already happened to one that is coming next week.

Some point, I want to convert into a little app and open source it, so you can install on your laptop so it's usable by more people. And have it detect more than just zoom.

https://jaiph.org/

I then used it to build other tools -- a personal time tracker and a Wesnoth-like game (both not yet published). Basically, I maintain a Markdown file with a queue of tasks, and I run a Jaiph workflow in a loop that automatically picks up tasks one by one and develops them with no human intervention.

None of them had share extension feature so whenever you are reading on the web or in a book you highlight the word share directly to the app and it automatically looks up the definition.

Also added a voice review (with gemini native audio model) so you can chat your reviews.

https://apps.apple.com/us/app/vocabulary-flash-cards/id67750...

https://anomalyarmor.ai/ - A tool for managing data observability and data anomalies.

Used daily by customers but also for my own work. These tools fill a gap that helps me get sh*t done.

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.

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.

https://theundercurrent.fm

It took more than a year. Why? Cloud infrastructure is too expensive.

Later on, I managed to crunch the numbers in the script, and realised I could dump them out and display them in a dashboard alongside the trade activity. So I built that too,

An excel spreadsheet could have done the same job as the dashboard, but the script for conversion was greatly aided by the AI tool. The work otherwise would have been a bit of manual coding and back-and-forth testing.

I looked for a decent remote keyboard app to use on the tablet, and found nothing I liked.

I ended up asking an AI to make something that served a webpage that connected back to itself via websockets. It provided a keyboard and touchpad on the webpage and forwarded events to uinput.

It works well enough on tablet and phone that I haven't got around to replacing the original keyboard.

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.

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.

I also built https://plugins.audio - a Dribbble-esque showcase of audio plugins.

It's been a dream to be able to work in the audio software space. I've been a musician, designer, coder all my life, and had a few moonlights with building audio plugins over the years. But now with AI at hand, I can use it to fill that missing technical requirement while still retaining my domain expertise (music/design).

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

It’s getting good traction in South America!

https://www.reversecam.com/

The front camera apps always show the mirror preview. Most of us hate photos others take of us, but love our selfies. It's because we groom ourselves and find our perfect angles using the mirror preview. So it's jarring when we see the photos of us taken by others. I always wanted a camera app that showed the non-mirror preview. Surprisingly most camera apps don't have this option. So I created this app to scratch my own itch:)

Note: Photos and videos are only stored in the browser. No data is sent to any servers. You can also install this as an app from your browser since it's a progressive web app.

- create your own coloring pages - https://www.coloringsai.com

- World Cup Prediction Pool - https://www.wk-pool.com

And many more

https://football.sensecall.co.uk/

Other parents on the team love it. The live sharing is pretty handy when some aren’t able to watch the game.

- 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

- An analysis pipeline that takes data from D1 (storing user searches), Posthog and Clicky (analytics) to periodically generate user journey reports.

- halalcodecheck.com - a database of emulsifier codes and food ingredients. Building this with the goal to help consumer verify and find alterantives of food ingredients across US, EU / UK and Asia.

A git worktree shell utility to quickly switch/manage git worktrees, and a neovim telescope picker which switches all the loaded buffers into the worktree version: https://github.com/jasonwoodland/wt

A terminal multiplexor plugin for neovim: https://github.com/jasonwoodland/terminal.nvim

A neovim session management shell utility (and telescope picker) to switch neovim sessions—no need for tmux or screen anymore: https://github.com/jasonwoodland/nvs

A NeXTSTEP-inspired menu for macos called NeXTMenus: https://github.com/jasonwoodland/NeXTMenus

A custom harness for pi agent which implements strict plan/review/implement iterative cycles and approval gating

A dynamic wallpaper utility for macOS changes the wallpaper when switching between light and dark mode — also useful for setting tiled bitmap backgrounds: https://github.com/jasonwoodland/macos-dynamic-wallpaper

A small macOS utility that dims the screen on a schedule, reminding me to rest my eyes: https://github.com/jasonwoodland/EyeSaver

https://github.com/LukaWe/espCoinWatch - espCoinWatch, an ESP8266-based Bitcoin/Crypto Ticker with Weather Support.

https://github.com/LukaWe/LocalExifGeoMap LocalExifGeoMap - privacy-focused, browser-based tool to visualize and analyze GPS data from a batch of photos. generate interactive maps, heatmaps, elevation profiles, and trip statistics. etc.

I think it was (a good idea), and AI made it easier for sure.

https://github.com/ncruces/wasm2go

Everything was built with AI as part of a 12-in-12 challenge I'm doing, where I'm building 12 products in 12 months. https://twelve.zamith.pt/

Quietbox (https://quietbox.zamith.pt/) - Clear spammy emails from your inbox

Vertical RTL by default, three paper modes (washi/sumi/ash) Offline reading, saved-list + per-position bookmarks

https://sutra-reader-3x2.pages.dev/

https://github.com/jessepcc/sutra-reader

A knowledge base for my research area, with tools for paper ingestion and search.

An md file to html presentation tool, there are several but this one helps me.

A review tool that splits a PR or branch intelligently into modules, and does per module reviews and global reviews for different aspects, and then summarizing that into a report. Can be used with multiple different harnesses. Written as a Python project, but build-time assembled into a single-file Python script with uv run --script shbang line.

* Image viewer that can handle really big photos + run scripts via custom keybindings + CLIP search: https://daniel.lawrence.lu/blog/2025-10-22-sriv-simple-rust-...

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

https://github.com/delecti/toof

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.

While I was doing it I needed to render those diagrams as ASCII and I was surprised there's no Python library for Mermaid to ASCII. So I wrote one: https://github.com/fasouto/termaid (https://termaid.com/)

Besides, I made a lot of automation scripts (mostly using Ruby) that run on my raspberry pi to fetch/parse/crunch things and notify me on my Android phone through a self-hosted https://ntfy.sh server.

- A Chrome extension to make design comments and ASCII wireframes right on the page you're working on and feed it to your AI coding tool as a prompt https://getdesignjam.com/

- An iRacing overlay to compare the telemetry of a reference lap against your live data https://flylapsim.com/

It's been a ton of fun to be able to dabble in software thanks to AI. Especially for small personal tools like these it's so powerful

https://farseek.io/

https://github.com/jazzido/bvcplay-tizen

And now working on an inference engine specifically geared to low mem situations. Both basically vibe coded. Not broadcasting either project widely as they remain unstable, unpolished side projects.

* Codjiflo: A code review tool inspired by Microsoft's CodeFlow: https://codjiflo.net

* A virtual replica of a digital readout (DRO) for operating a CNC machine like a manual mill: https://el400.vza.net

* Reverse engineered CNC pendant integration with CNCjs also for operating a CNC machine like a manual mill: https://github.com/pedropaulovc/cncjs-pendant-whb04b-6

* A 'docker compose' to provision email, chat and documents for human-AI hybrid teams where you can take over AI's agent's credentials temporarily: https://github.com/vezzadev/roster

* The CNC stuff will come handy for a bigger project I have to create a 1:1 replica of Albert Michelson's harmonic analyzer: https://github.com/pedropaulovc/harmonic-analyzer

* Reverse engineered Hik-Connect P2P CCTV protocol for integration with OSS like Home Assistant and Frida: https://github.com/AlexxIT/go2rtc/issues/2289

* Some patches for different OSS projects like improvements to MCP tools, Playwright, Claude Code, etc.

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.

> agentmux

> Configurable tmux agent launcher. Define AI agents (or any CLI) in TOML; sessions auto-launch the correct agent, tabs are colour-coded per agent, and prefix m cycles through the list.

https://github.com/lockyc/agentmux

* 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

All spamming with messages and news - so I made python scripts that use the apps API to get the messages (exams and changes etc) and puts it into our family telegram group chat if relevant

I just can't sit here every morning 20 minutes on my phone logging in checking everything just to find out the food plan has changed ...

A game engine / MVP game

A tool to replay shell commands during presentations

A tool to generate ttrpg book pdfs from obsidian markdown

A tool to generate confluence pages from markdown

Similar to another tool called process-compose but with a CLI that mimics the docker one more closely and doesn't start a TUI by default.

Useful if your team's on nix and doesn't need containers.

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.

https://plunio.app

Any parents with kids that cry in the night might benefit!

I am planning on building a run club app next trying to build a community of my own

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...

So I made, kind of last.fm/waka-code for agents where I track (anonymous) usage per project

here is the example of my profile: https://clankerlog.ai/kodisha

Data is fully anonymous, all I collect is (agent, model, project name [can be mapped to something else to hide the true name]) and everything is opt-in by default (per project)

I use Linux on my computer and an iPhone and wasn't happy having to use a cloud to sync my data between my devices. Syncthing/Synctrain + my apps allow me to keep everything on my private network, without ever touching a server or having to self-host something like Immich.

https://j23n.com/public/posts/2026/localios

https://github.com/michaelteter/docgen : create a single text file of your entire project, with a tree and some other useful bits. This is good for dropping into an LLM or research notebook instead of giving an LLM access to your actual project folder. It also can be put in your pre-commit script so you always have one single doc you can diff from one commit to the next.

md2pdf: markdown to PDF, relying on defaults and optional config files or cli args for formatting choices (such as page margins)

md2gslides: markdown, converted into slides, and using Google Slides API to generate the doc in my Google Drive. This saves me so much effort (I teach, so I make lesson plans/presentations all the time).

get-music: TUI app that lets me search Youtube and easily queue up to download one or more of the search results. Then I take the downloaded content, split out the audio, LLM process the video title, add metadata for music, and then provide an easy command interface for local searches and playback of downloaded content.

bookmarks: TUI for slurping all the URLs from my browser, LLM-tagging each url based on the tag list I provide with the prompt and url, and lots of features for managing priority, show/hide tags, etc. This was to help me stop worrying about having a hundred tabs open. Now I can just sweep them up into my own private, encrypted (sqlite) db.

ESL-Planner: Complete web app for building class plans for teaching English (based on params, such as student age range, skill level, specific teaching language (what we want to teach), etc. It's close to being ready to productize and release as SaaS, but I built it for myself initially.

Numerous other tools plus a guide doc listing all the tools and what they do. These resources are then made available to LLMs when I'm developing, saving me (and the LLM) the time of hand-crafting the same tooling over and over.

https://gregryork.github.io/EpicRpgBattleMap/

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.

1 year later, with no js/ts skills at all, i got 10 custom plugins, several forks where i fixed bugs and some custom adapations, dozens of scripts and snippets and what not

Now obsidian works for me like I want, and still every day I use it Im still in awe

It is a bit hard to describe until I make a video but basically I seem to have changed the fundamental unit from a document to a chunk and it is just awesome

none of which would have been possible without AI

- https://github.com/sethdeckard/loadout : TUI and CLI for managing a personal library of Claude Code and Codex skills across your machines.

- https://github.com/sethdeckard/atlas : TUI and CLI (also works as "cd launcher") that creates a smart, automatic map of every Git repository under your projects root.

I'm using these almost daily.

- classless CSS library: https://leftium.github.io/nimble.css

- HN client: https://hn.leftium.com

- local realtime streaming transcription prototype: https://rift-transcription.vercel.app

---

These projects were started without AI, but heavily augmented with coding agents:

- https://weather-sense.leftium.com

- console.log replacement: https://github.com/Leftium/gg

- Thin layer over Google forms/sheets: https://veneer.leftium.com

A tool to periodically sync Device 42 data to Netbox (work).

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.

https://docking.cc

A Linux dockbar with tons of applets and support for x11 and Wayland. Works on Gnome and KDE. I always wanted to write one as I have been involved with several open source ones, but it is a lot of time to go from scratch. I use it everyday, and I am enjoying it so much!

I also got it to write a mysql DB importer I could use instead of "mysql", since I often import large DBs locally. I wanted progress, estimated completion time, and I wanted it to prevent my machine from going to sleep during the import.

Check sugar memory for the latest thing we were working on.

2. The second thing is when making changes across a large codebase agents are also dumb at figuring this out and also grep 300 things, using tons of tokens. Instead I say

Check RemembrallMCP to analyze the impact of the change.

1. https://github.com/roboticforce/sugar

2. https://github.com/roboticforce/remembrallmcp

2. An app that receives forwarded text messages from my iPhone and then outputs the text message onto a dedicated television connected via a raspberry Pi to display a cold-war era style GUI teletype sort of interface. It actually looks really stinkin cool

Updating my machine used to be a dozen scattered commands: apt, fwupd, and a pile of dev tools I want kept current (node/npm, go, claude, opencode, plus binaries like kitty and lazydocker) that each update their own weird way. Now it's one Bubble Tea dashboard that checks each tool's installed version against upstream and only downloads what's actually behind, so I can see at a glance what's current and what's not. Adding a new tool is easy enough that I just toss new ones in as I start using them.

It also has a cleanup mode that hunts down all the pesky cache files that quietly eat your disk and reclaims the space in one pass, which has saved me from the "laptop full again" scramble more than once.

Currently, testing it privately and tweaking to make it awesome.

Another tool I made for myself is automated video editor (takes folder of raw photos images, and generates edited video that can be shared online). Used it among other things to edit all my GoPro raw footage laying around (hundreds of files).

1. home automation, access point management, solar/battery health monitors

2. family week management with schedules, todo's, scripture of the week

3. page-to-pod (browse, click one button, TTS to podcast episode on my phone)

4. daily summary of AI news to a new pod episode on my phone

5. easy theme switching from light to dark on my mac

6. and more....

what does this mean about the future of software? looks like consumer software will be "instant and on demand".

imping - PingPlotter-like app. They didn't have a Linux version and I'm a paying customer, so I vibe coded this one: https://github.com/zenakuten/ImPing

utcolor - text colorizer for Unreal Tournament 2004 https://github.com/zenakuten/utcolor

utquery - Unreal Tournament 2004 Game Browser tool https://github.com/zenakuten/utquery

utstatsdb - This is an old project that did not work anymore with modern php+mysql. I had claude fix it. https://github.com/zenakuten/utstatsdb

- 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.

- 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

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

It's really removed all the pain points from my practice hours, especially when internet access is shaky.

Of course, it was great to have exactly the features I want, and I enjoyed learning some new things.

https://donohoe.dev/subway/map/

And a MCP-powered error tracking rails engine: https://dlt.github.io/blog/posts/mcp-powered-error-tracking-...

Runs entirely in the browser, no tracking, no analytics, no ads.

I also built https://github.com/lnenad/difiko as AI generates a lot of code that needs a nice way to review it.

That way, you can who played without ruining the result. Then watch highlights in peace!

https://www.attie.app

It follows a lot of the conventions of Rails which is probably why it has turned out quite well

https://github.com/mbvlabs/andurel

- A self-hosted comment system for my blog (https://github.com/karthikeyankc/discuss).

- A custom RSS reader with AI capabilities to keep tab of our competitors at work.

- A git-based CMS for my personal blog (which was also built with AI).

1) Use chatgpt pro from codex cli, opencode, claude etc as you can't get it via API. This has been the biggest boost in productivity for me as I don't have to copy and paste.

https://github.com/agentify-sh/desktop

2) A small gate to make sure any agent cannot run destructive rm -rf or git reset --hard commands, it has saved me many many times

https://github.com/agentify-sh/safeexec

3) For mac users, summarizes and speaks out loud after codex finishes a turn

https://github.com/agentify-sh/speak

(Transcribes the audio, marks the timestamps, so you can delete a word in the transcript, and it’ll crop out that segment in the audio)

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.

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.

* Highlight do-follow links.

* Spoof GPS - I live in a non-english speaking country. Sometimes Google sets my location to my gps, despite having an english vpn. This is an attempt to correct that.

* Local translate, rather than sending everything to Google.

* (non browser) An SSH selection screen, so I don't need to remember the IPs

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.

- 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.

I write a Substack about the whole thing and have a pretty comprehensive list here: https://theautomatedoperator.substack.com/p/15-ways-im-using...

Bunch of security tools: Some are at https://diffsec.dev others:

https://github.com/diffsec/quokka

https://github.com/ihavespoons/hooksy

  - little visual web app cataloguing a small vineyard by vine vigour
  - 5 min web app that helps show my daughter netball zones per position
  - web app to track manual irrigation runs of 30ish taps across our property
  - a calculator to cost-compare types of retaining walls by length
  - a virtual card deck for testing a game idea
  - scripts to help clean up an unruly Gmail inbox

https://bgremovefree.com/

The wow moment came when it wrote syntax highlighting rules for 40 languages and file formats in ~10 minutes:

https://repo.autonoma.ca/repo/treetrek/tree/HEAD/render/rule...

https://archives.fifthrevision.com/color-generator/index.htm...

I also have a local zsh autocomplete macro that let's me type things like "git rename annotated branch" and ctrl-g and it will get me the actual command. There's also a ctrl-r mode that searches my history using natural language. This is connected to a locally run ollama so my keys don't leak.

Tubenote, a free YouTube video summarization extension. Mangata, a walking app that makes it easy to take notes and photos while walking. NotebookLM Clipper, a browser extension for importing content into NotebookLM. Knock, a notification tool that sends me a Telegram alert when Claude or Codex finishes a task.

and more products are also in the works.

It's called Commonplace: https://zby.github.io/commonplace/

https://github.com/frankieg33/fade - A program that minimizes screens inspired by Marco Arment's Quitter https://marco.org/2016/05/02/quitter

https://github.com/mxpv/podsync - a personal video podcast feed through podsync

https://apps.apple.com/us/app/spaced-math/id6770719584 - ios application for my kids to learn mental math.

a daily newspaper for my 3 kids with themes around what they are into, jokes, and today in history.

https://github.com/frankieg33/MewgenicsBreedingManager - mod for the game Mewgenics. it had ~600 users which feels amazing.

Fun to build again, host on bare metal and all. Learned a lot!

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

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

Can be used to resize images, but the main purpose was pixelation for a game I was making.

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.

https://github.com/haydenk/homestead - another Go project, working on a better uptime dashboard that can also be the main homepage for accessing homelab resources.

I also used AI to find and create issues and milestones to for me to get the project to 1.0.0

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.

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.

On top of that, I made a Python parser that's meant to improve upon the awesome `orgparse`: https://github.com/Idorobots/org-parser

And now I'm building a CLI for Emacs Org-Mode, mostly focused on ad-hoc querying, agenda planning, etc: https://github.com/Idorobots/org-cli

- 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

Code: https://github.com/VadimKey/xorpingtonian

Catalog (in Russian): https://vadimkey.github.io/xorpingtonian/

During vibe coding I found that emojis are not that simple as I thought about them.

Being proud of the result.

THAT is a real game changer LLMs allowed me, both in my professional and my casual life.

For example this:

https://github.com/yodalf/coincan.git

or this:

https://github.com/yodalf/kiosk.git

https://github.com/kavehtehrani/devprune

Among many others

in case you forgot instruct your ai text generating tool to do so: replaces — with -, removes emojis and changes quotes to look like human-typed (even though they are not grammatically correct)

Allows me to efficiently work on multiple tasks in multiple repositories concurrently.

https://github.com/hn-ai-podcasts/browser-extensions

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.

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)

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.

https://third-space.astride.com.au/invite/c0378a6f-b1b9-4c26...

https://github.com/btucker/graftty

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.

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.

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.

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

https://github.com/gitsocial-org/gitsocial

Automatically rename screenshots: https://github.com/amichae2/screenshot-renamer

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.

I can once again write Clojure apps for my phone, which is fun to do by hand, unlike more conventional tools for writing Android apps.

A web harness for another open source project (CHIRP) which lets you program channels into all kinds of handheld radios (HAM).

FOSS https://github.com/klinquist/Notesync

- I coded myself a portfolio manager to manage all the projects that I have

- secrets management tool to avoid accidental leaks of tokens by AIs

- tool for automatic creation of training/product presentation videos for web apps

- sales training app

https://github.com/jeffnv/lockin

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.

Screenshot here: https://x.com/LyleMakes/status/2063784301594853657/photo/1

https://github.com/dvelton/eyeball

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

No code or docs was hand written for this one.

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.

Revamped my blog to have a funky 3d background and animated cursor after years of minimalism: https://bdickason.com

A little screensaver inspired by After Dark: https://bdickason.com/static/experiments/flying-stuff/

A little toy using (mobile) screen tilt: https://qwertle.bdickason.com

A funky RTS designed for mobile: https://chasm-nine.vercel.app/

A start of a little 3D RPG: https://misty-woods.vercel.app/

Note: all experiences in varying states of completion ¯\_(ツ)_/¯

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

https://github.com/klinquist/machinemon

- https://www.yourfriendly.ai/. a desktop pet that lets me have an ai chatbox readily available

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

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

Pretty happy so far

This started off as a fancy cron with webhook and became a comprehensive runtime. I have been using it for months on several systems.

token speed calculator - for estimating tg/s of ai based on ram speed and model size/params this helps in comparing different hw, estimating likely speeds i will get on hardware

prompt assembler - to create prompt and context once and reuse it in different ai's, picking and choosing context in a prompt, creating agent.md etc.

dashboard builder - for viewing gsc, ga, stripe data in one place

At first glance, it's just a nice version-controllable, parseable DSL. But I also made succinct prompts with the grammar that lets LLMs produce and reason about Satsuma, a language server, CLI tools for the AI tools to use to navigate specs token-efficiently, reason about lineage, pretty viz in vscode plugins/syntax highlighting, some agent skills etc. There are metadata conventions for succinctly representing a lot of quirky formats and capturing common analytics conventions (scd2/Kimball/datavault/etc c.)

Yes, yes, I may have gotten carried away.

But I'm finding it really useful as a specification tool in projects for reverse engineering mappings from code/workflows, generating new code (dbt, Spark etc.)

This definitely isn't something I would've had the bandwidth to push this far before AI!

Will improve the read me

It has less features (no OG media or title/story analysis via Bedrock) but it focuses more on the features I like/need from an HN client

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

https://github.com/brendoncarroll/nnc

I use it for running agents locally.

  nnc run /usr/bin/opencode --preset agent

https://github.com/brendoncarroll/nnc/tree/master/presets

Presets are written in Jsonnet, and resolve to a list of things to pass through from the parent process into the container. Presets can reference other presets, so you can build up arbitrary rules for passing files and devices into containers, give those rules a name, and reference them later.

https://buckets.joelryan.com

https://packagecontrol.io/packages/Claudette

Currently working on a Gmail clone.

https://github.com/mohsen1/yek

It updates itself in a day or 2 when card benefits change

https://guitar-tools.eejalab.xyz/

There are plenty of other tools already that do this but hopefully this one adds some quality of life niceties such as dark mode and a mobile responsive design that seems nicer to use than the others out there.

Hope the colours look ok. I'm a colour blind person (deuteranomaly) and I've optimised it for what looks good to me. Am open to adding a mode in line with what regular vision people might prefer.

No frameworks used, vanilla JS. No sign ups. Data/state persistence is purely local storage.

Absolutely no commercial interest here. Built this purely for the love of it. Will forever be free.

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

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

https://sisuonspeaks.com/

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

https://github.com/ericfortis/tabular-eye

https://tools.dsebastien.net/

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)

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).

Eg: push a button, it shows that it's working for a while, then strongly flashes when it's done (success/failure). When you have it right under the monitor, it's like a macro pad for long-running things.

This reminds me of some of the very early peripherals you'd see on the Alto and other computers. I was surprised something like this didn't seem to exist, but maybe I'm just terrible at searching.

When you install the CLI, it (with your permission) asks to update your base agent prompt files (e.g. `~/.codex/AGENTS.md`, or `~/.Claude/CLAUDE.md`) with info about how to use the tool.

This means all your agent chats know about SDocs, and it’s nearly always your agent which invokes the tool: “Hey Claude, sdoc me a list of all my open MRs”, etc.

I did a ShowHN about it here: https://news.ycombinator.com/item?id=47777633

After asking agents to make the same types of changes over and over again, I decided to make a tool that would just tell the agent that its code needs improving. I figured that if I could get the agent to self-review and improve the code it writes, that it would save me time when I finally come around to reviewing it.

Tool: https://github.com/thempatel/mdlr Blog: https://www.thempatel.com/2026/06/06/slop.html

The one tool i noticed could be helpful given the volume of screenshots i share with the agents is screenshotter: just a simple script that watches my screenshot folder and compresses the images so i can save some bandwidth and hopefully some tokens https://github.com/mgranados/screenshotter

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://github.com/TrevorS/rmux

Reminder.dev - Quran app and API that includes RAG search to provide a more authenticated source of summarisation. The first thing I dabbled in with AI.

Micro.mu - Rebuilt my entire product idea from 10 years ago as a super app for daily digital habits. Something I use everyday for myself.

Aslam.org - An islamic knowledge base that uses sources of data as a way to ground AI chat and make notes. Very useful tool that I'm using on a daily basis.

Go-micro.dev - Totally revamped the open source project, docs, etc with Claude.

- A chat-based web app for ad-hoc telemetry data visualization. - A firefox-extension meeting transcriber - A personal chief of staff - A web-based personal finance budgeting tool (no AI at runtime, obviously) - An iOS and Android app for solo work with a dead man switch if timely check-ins don't happen - A custom dotfile/machine config manager that works the way *I* want - A bookmarking tool/web clipper that puts together daily content-only collections from what I've been clipping and send them to my Kindle. This one I actually intended to make a SaaS, but meh. Being able to put together quite big projects by myself for myself in a reasonable amount of time is such a joy.

Art search for magic cards

Side note: before coding agents I would not get passed the branding and login page.

I needed to see health of many Function Apps and Container Apps in a single page

https://github.com/RobbertH/azpect

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?)

1. A Mecrisp-Stellaris Forth LSP for the Helix editor (Python) 2. A CMSIS-SVD Sqlite3 search and paste pop-up window for Neovim when editing STM32xx embedded Forth programs. (Lua)

https://mecrisp-stellaris-folkdoc.sourceforge.io/

- a slop detector / browser extension that filters slop replies from twitter/hackernews/reddit: https://slopsieve.com/

- tweethoarder ( https://github.com/tfriedel/tweethoarder ), saves my liked tweets and makes them searchable

- mattermost_archive - syncs all my mattermost channels and makes them searchable via an MCP in claude

- https://github.com/tfriedel/asana-exporter - same thing for asana

- https://github.com/tfriedel/dynalist-archive - same thing for dynalist

https://github.com/yen223/hotpot

https://github.com/mretallack/OpenEPaperCliTool

----- 3d printer pipeline, so its can print stuff directly without having to use the computer to set it up.

https://github.com/mretallack/3dprinter

----- Experiment with creating a Abdroid Auto app for phones that cannot run real AA. (WIP)

https://github.com/mretallack/AndroidAuto

----- A android 3d clay modeler to create models for 3d printer, with stl export.

https://github.com/mretallack/ClayModeller

----- Uk Fuel finder python lib and Home Assistant intergration for showing fuel stations from UK gov api.

https://github.com/mretallack/ukfuelfinder https://github.com/mretallack/ukfuelfinder-ha

---- Reverse engineer cheep drone video feed, from drone found in charity shop

https://github.com/mretallack/DroneCamera

---- App to send voice to camera using mqtt.

https://github.com/mretallack/CameraSpeaker

---- Added ONVIF to an oss rtsp android app.

https://github.com/mretallack/cams

---- Added Home Assistant to Dicio Assistant.

https://github.com/mretallack/dicio-android

---- Added telegram bot interface to kiro, with group support.

https://github.com/mretallack/kiro-remote

https://convert.neocities.org

When I want the program to reformulate a sentence or phrase, it sends the sentence to an AI that provides word or phrase suggestions. I've connected this to Tinfoil.sh (not affiliated) via API key.

Now, I have a much more private DeepL Write replacement with a snappy, consistent user experience that costs much less. Unfortunately, the suggestions are not as high quality. It's very much an 80% solution. It was still fun!

Most of the rest concerns scraping. The biggest project is an extraction tool for the German transparency register that I need for work.

https://gergltd.com/aperturelab/

It really helps us to not forget to spend significant time with each other when life is busy.

A rant follows.

I've generated probably as many lines of code by this point as I've written myself over the past 5 years or so.

I found AI generated code mostly very frustrating, kind of low quality in its own way, and too complex. I have pages and pages of instructions to guide the agent(s) to do a better job at this, and it has gotten better, but the fundamental limit of this technology is tangible.

Like, okay, CPUs still get faster every year, and every now and then someone makes a breakthrough and we get a bump in speed from something. But when you write high performance code, you very quickly run into hardware constraints, like how fast information can move and how far away components are from the CPU cores themselves. People keep saying performance isn't THAT important, and that modern hardware is so fast and amazing, and that they struggle to even find a way to use all of their CPU cores and RAM with their little app or program or game. Yet here I am, writing code that will noticably speed up if I run it on a CPU with a little bit more L1 cache.

This is similar to how it feels to program with AI when you're reasonably competent (to put it mildly; I avoid the 10x developer label because comparison to others is very silly). Everyone keeps saying it's getting so much better, and it's so good, and worrying about code quality and architecture is dumb because we can move so fast it doesn't matter. Yet here I am, writing code by hand because I tried doing it with AI a couple times and it just doesn't hit the mark.

I'm not doing anything special, I just have high standards and a good amount of experience when it comes to software quality, performance, and maintainability, which is why I keep getting hired. I'm convinced that people who think their AI generated software is good are the same people who write short variable names and think it makes their software faster (hyperbole, but you get what I mean).

I can feel when I hit the limits of the hardware, and I can feel when I hit the limits of LLMs, and I know for both of them that a 2x increase in performance will not change what is and isn't physically possible.

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.

A grocery app tailor made for me and my wife, offline first, seamless instant sync, barcode scanning, GPS/location hints

A macOS native high performance infinite canvas scribbling app for use with my Wacom for thinking through ideas

Lots of stuff for one pretty much finished video game, and currently lots of stuff for my new video game

- 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)

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.

- gcode sender and generator https://mycnc.app

- CNC simulator https://sim.mycnc.app

- Cabinet design with door/drawer designer https://cabinet.mycnc.app

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

Presentable: a photo library sorter with Ai powered organization assistance, a compare canvas with various viewing modes and customizable folder sorting shortcut templates (wip).

AlwaysWhisper: a tool that let's me attach STT to my entire OS, with custom wrappers for different programs, adding theoretical voice control to any software (wip).

ScreenLoader: an Electron based tool that can load any web source as a kiosk app, full of useful features like keep-alive, covering multiple screens and tracking output logs.

Inputboard: a unified all-inputs hardware board, that transfers input data to any prototype I want to work on using an optocoupler, so I won't have to fiddle around with setting up clean and reliable inputs from cheap Chinese components every time I just want to test something.

Squire: an agentic board game helper, that can ingest a manual and will hopefully help decrease the time spent on endless discussions about seemingly conflicting rules. It should also be able to help me play a game when I don't fully understand the rules myself yet (wip).

NodeRunner: an agent that plays the WikiGame, focusing on speed, efficiency and token usage (the result of a fun competition with a colleague).

Sonic Bloom: more of an experiment than a tool. It's a wireless piece of custom hardware, that listens to conversations, sends data to an LLM through fast STT and returns a color choice that matches the topic being discussed to the hardware, which then controls an LED ring. It also has a small display that explains the logic behind the color choice.

Image-to-story: a VLM tool that kickstarts a written story using an image and has some rudimentary tools to expand on it based on user instructions (wip).

At-work-or-not: and Android app/website where colleagues can check if I'm working from home, if I'll be at the office or if I'm not working at all. Also doubles as a private record for tracking transport expenses.

SharedMaps: a Maps based website where groups of people can share custom categories of geo locations and drop comments on them.

VMG: an image format that includes audio with images and offers TTS input to easily add narration.

Who wants Coffee: a small Android app to help me remember who wants to drink what when I go for a round at the office.

And a pile of Python scripts for smaller useful tasks.

Nothing major, and only works with my infra, but it saves me a few minutes a few times a day to just be able to check the tab, and if there's an alert load up the full stats page.

- a stateless dashboard for work that collects from 6 other APIs

- a refactor of a huge function with 8-deep indentation into readable small functions

- a road trip game for my kids where you take photos of things from the car

- 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

Here is a website I made with places.js for DC area board game events. https://dmvboardgames.com/

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 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.

https://github.com/clashleyca/magpie

Browser emulators / games

https://nesvibes.tsilva.eu/ — Browser JavaScript NES emulator in ~2.5k LOC

https://scummweb.tsilva.eu/ — Run ScummVM games directly in the browser

https://github.com/tsilva/REFramework-chill — Anti-nausea improvements for Praydog’s Resident Evil VR mod, specifically for Resident Evil 7: movement vignette, snap turning, etc. WIP.

AI / ML browser experiments

https://llame.tsilva.eu/ — Run small LLMs in the browser with WebGPU

https://aipit.tsilva.eu/ — Debate simulator: pit simulated personas against each other

https://aigrounds.tsilva.eu/ — Playgrounds for experimenting with math, AI, and ML topics. WIP; lots of slop and most are unreviewed.

https://modelviz.tsilva.eu/ — ONNX model graph visualizer

https://modelarchviz.tsilva.eu/ — View model architecture diagrams, codebase, and paper side by side. Includes a chat bot that can see selected content and select content itself. WIP.

https://embeddingviz.tsilva.eu/ — Visualize model embeddings and/or layer activations for different content with PCA, UMAP, or t-SNE. WIP and poorly tested.

https://github.com/tsilva/dlab — Workbench for deep learning experiments. Open the repo in Codex, pick a training target, e.g. maximize validation accuracy on CIFAR-10, and ask it to start a research track. Then collaborate on training runs, evaluations, sweeps, and iteration toward the goal.

Datasets / visualization

https://minariviz.tsilva.eu/ — Minari dataset visualizer: https://minari.farama.org/

https://github.com/tsilva/gymrec — Record and replay gameplay from Gymnasium environments as Hugging Face datasets. Supports stable-retro environments such as NES, SNES, Genesis, etc.

https://github.com/tsilva/youtube2datasets — Convert YouTube videos to Hugging Face datasets.

Agent / coding workflow tools

https://github.com/tsilva/runbook — Run Jupyter notebooks on Modal through a CLI, with streamed outputs.

https://github.com/tsilva/agentpong — Run coding agents in VSCode/Cursor terminals, one per Aerospace window. Agents trigger desktop notifications when done; clicking a notification sends you to the correct desktop. I haven’t used this in a while, so I’m not sure it still works.

https://github.com/tsilva/agentbox — Run agent CLIs inside Docker sandboxes. Project-level config defines sandbox access. I stopped using this once agents got better built-in approval mechanisms.

https://github.com/tsilva/agentbridge — Use an agent CLI subscription as an OpenAI-compatible API server.

https://github.com/tsilva/claudesk — Agent coordinator for Claude, built before decent agent orchestrator UIs existed. Stale and probably broken now.

Personal workflow / GTD

https://github.com/tsilva/gmail2obsidian — Flush labeled Gmail messages to Obsidian.

https://github.com/tsilva/thunkd — Quick idea-capturing mobile app built with React Native. Sends notes to Gmail, which is my main GTD inbox.

https://github.com/tsilva/capture — Quickly capture thoughts to Gmail using an Alfred shortcut, for my GTD workflow.

File / document utilities

https://dedrive.tsilva.eu/ — Client-side Google Drive duplicate finder. Lets you choose which files to keep. Poorly tested; use with caution.

https://github.com/tsilva/pdfpress — Misc PDF tools: split, merge, compress, unlock.