alt Hacker NewsAsk HN: What are tools you have made for yourself since the advent of AI?
Comments
i created a “simcity for logs” to generate synthetic test logs and simulated data sets https://logsim2.vercel.app/
Started making Agentikus as a way to manage my -back in the day- multiple OpenClaws. Soon enough realized that many will have the same problem soon. And started adding features that I was missing on Codex and C. Code. It’s a fun ride.
Side note: before coding agents I would not get passed the branding and login page.
i built a program that watches wifi traffic and if it sees my phone connected to the office wifi; it marks me as in the office on our internal chat tool (Zulip).
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?)
Something to help me remember the order of my jokes when doing stand up.
azpect, a TUI for azure
I needed to see health of many Function Apps and Container Apps in a single page
A port of the open epaper lib used in home assistant, but cli based, and an mqtt interface to allow it to run on a different computer to.HA
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.
SAT>IP scanner with S/C/T and LCN support in <1kLoC Python
Has anyone used AI to manufacture entire physical gadgets of some sort?
- a youtube/podcast summarizer webapp. Summaries are getting synced with readwise reader. Example: https://toolong.stream/v/a7g5p6PkWH4JwwtKloXhlw/keynote-linu...
- 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
macOS spotlight like command generator for terminal https://github.com/64bit/commandOK
No Nonsense Containers: a simple Linux containerization tool, secure by default, with support for presets.
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.
I made my own webclipper - dont trust browser extensions
hotpot: google authenticator but for the command line
1. A personal dashboard that is gloriously incongruent, but solves almost every problem where I have to glance at my phone: my home and car battery charge levels, my failing github actions, planes overflying my house, medication tracking, Life360 integration so I can ensure my kids charge their phones, sports and finance tickers, birthdays, fuel prices, public transport, integration with my bathroom scale....the list goes on and on. It has ticker mode, card mode and alert mode and lets me add features via a Github and Claude API integration.
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 scrapper / browser mcp with camoufox. plug a vision llm to that bad boy and you can defeat any google / cloudflare captcha.
retro-inspired fully custom, swiss army knife style notepad --
I wrote a tool to give agents signal on what is and isn't clean code. I find myself spending an inordinate amount of time reviewing agent code.
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
Oh man - I've created more than I can count at this point, but here's some of them:
- 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.
An on device iOS ad blocking podcast client
Not really a tool but converted a hobby swift app to a webUI animated showing mexico city and london when there's rain https://tlaloc.cloud/
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
German tax preparation command line tool
As another post pointed out, AI as a field of research started about the time I was born (LLMs are another matter of course). So everything I've created has been since that time. Some of my software tools are listed at https://wiki.tcl-lang.org/page/Colin+Macleod - no form of AI was involved in any of them.
I vibe coded two apps, I program but not in the languages used in the apps. I'm utterly clueless about Lua and Python. Both apps work fine and I use them all the time myself.
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)
I made an absolutely essential tool which is a “Trump bingo” game.. makes following his tweets more tolerable https://wtf-fantasy.com/
scratched my own itches related to OCPP, latency, git, ssh and JMX. none involved AI
Mostly for myself (stripe isn't actually even hooked up anymore afaik), but a Mandarin language learning app: https://nextword.app .
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.
Over the past few days I have been making a spell checking TUI app. I used AI (meaning: free Gemini web interface) to discuss various aspects about the apps and debug compiler errors ang suggest useful rust crates for various problems.
Just a more helpful discord chat generally. It also gaslights you too!
Here is the tool: https://git.sr.ht/~asibahi/hoopoe
I've been reading Finnegans Wake and not making much sense of it so I wrote a data pipeline to scour the web for interpretation books / guides (which I also can't be bothered actually reading) and coupled it with an prompt to image pipeline. It's now a readable albeit silly picture book to go along with an audio book... I call it finnegans slop.
A website that tracks when we last went on a weekend trip and other kinds of things, and reminds us with a cute friendly (not AI written) email when it's time to plan something again!
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.
I get annoyed that existing tools have limitations so I fix them or build my own:
- 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)
cross-platform apps with data sync that breaks frequently
Thanks for the reminder, I made a very simple and small mac os guitar tuner and intonation app (all others are either paid, have in app purchases or are outdated) that I still need to publish!
CodeMerger: https://codemerger.nl I've never liked the lack of control I feel using agents or tools like Cursor or Antigravity. I found myself having much better results simply pasting full source code in free chat, so I built a tool around that philosophy and I've been exclusively developing with it for a year now. It includes a Project Starter and code architecture analysis tool.
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.
Workflow:
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."
Vibed a ton of small projects, mostly for my own usage, to understand what agents could do, or just to satisfy my curiosity. Most are rough around the edges, and a bunch quickly became obsolete as agents got better and I stopped using them.
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.
[flagged]
[flagged]
[flagged]
[flagged]
[dead]
[flagged]
[dead]
[flagged]
[dead]
A bash script to build my eleventy website with qrencode batched for qr generation.