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

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

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.

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.

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

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.

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

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

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.

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

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.

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

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

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)

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

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.

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.

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

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.

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.

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

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

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

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.

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

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

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

https://theundercurrent.fm

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

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.

* 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

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.

- 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://tools.dsebastien.net/

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

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

Art search for magic cards

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.

- 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

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

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

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

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

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

https://buckets.joelryan.com

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

https://matry.design/

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

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.

https://github.com/jeffnv/lockin

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

https://github.com/mohsen1/yek

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

https://github.com/mbvlabs/andurel

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

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.

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://github.com/ericfortis/tabular-eye

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.

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

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

https://www.attie.app

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.

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

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.

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.

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

https://github.com/diffsec/quokka

https://github.com/ihavespoons/hooksy

https://github.com/clashleyca/magpie

https://github.com/TrevorS/rmux

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.

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

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

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

Among many others

https://www.motormait.com/

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

Pretty happy so far

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

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

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

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.

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

https://github.com/delecti/toof

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

https://github.com/RobbertH/azpect

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

https://github.com/klinquist/machinemon

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

- 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

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.

https://packagecontrol.io/packages/Claudette

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

https://sisuonspeaks.com/

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

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

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.

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

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.

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)

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.

No code or docs was hand written for this one.

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

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

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.

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

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.

https://convert.neocities.org

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.

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.

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

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

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

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

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

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/

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.

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.

- 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

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

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

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

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

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.

(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

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.

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

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

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

https://github.com/yen223/hotpot

- 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

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

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.

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.

- 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://github.com/hale-lang/hale

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

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.

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.

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.

- 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

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/

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