1,991 karma · joined May 31, 2011
noah@housecat.com
Previously VPE at GRAX, engineering at Segment, co-founder and CTO of Convox (S15) and platform architect at Heroku.
https://github.com/nzoschke
I’m putting personal attention and tokens towards replacing Pioneer / Alpha Theta Rekordbox (music management for DJs).
The software is old and clunky, has a ton of features I don’t use, and can’t customize what I do use. And it’s enshittified with ads and popups and an expensive monthly subscription.
One big motivation for me is that it is FUN to rebuilt it with a coding agent. I’m learning a ton and the custom tools actually work.
I know I’m not alone.
Recently me and a bunch of DJs reinvented how we manage metadata for our collections.
The TL;DR is use SQLite for everything. Both a local central database describing the entire catalog, and one “sidecar” database for every song representing its individual metadata.
The huge advantage is it stores metadata that ID3 tags never imagined like beat grids and phrases and cue points.
The other advantage is agents crush manipulating data that is in SQLite. Chatting with my music collection feels better than any music library app did.
Of course tools also import and export to native audio file tags and use the musicbrainz API.
Looking for feedback and other music nerds that want to collaborate on this approach.
https://deadca7.com/blog/deadca7-open-music-database-specifi...
Storage is Hetzner Storage Box which so far feels great. Cheap and supports SSH SFTP WebDAV, so you can use rsync or restic and browse artifacts over www.
It feels a little slow hosting in Germany but using from US. But I haven’t found a provider with the same cost / features.
Any alternatives folks use for backups?
I’ve been using exe.dev to throw up micro sites. It has a built in web agent and first party mobile app agent. And any coding agent that can use “ssh” (all of them) can easily figure out how to drive it.
It also has a lot more developer and PaaS tools like GitHub integration.
RIP Heroku for imploding before the wave of vibe coding. We had the ability to “spin up a free app on the internet” before it was cool.
> Like ChatGPT in 2022 was exciting because it was a general-purpose chat model that could generate all kinds of texts, one of the reasons the tech community is excited about Jev is that it is the ChatGPT moment for classification, where it can cheaply classify all kinds of text inputs without having to fine-tune a custom classifier for each task.
We've been comparing strategies for classifying email and Jev is looking promising. I compared some strategies here: https://housecat.com/blog/classifying-email
I just added an agent / coding agent into an email app, and doing it through `codex` and its Codex App Server couldn't have been easier, and the results are very compelling.
The open source harness, API around it, and friendliness for connecting a subscription puts Claude to shame right now.
A few more thoughts here https://housecat.com/blog/introducing-housecat-agent
We've been experimenting with Jev for classifying email, some thoughts here: https://housecat.com/blog/classifying-email
Flagging AI written email is a much requested feature too.
Large parts of the JavaScript application space too.
Language consistency, ergonomics, standard library and performance matters, and JS has major warts here. I bet when these languages are 30+ years old like JS is, the software landscape isn't dominated nearly as much by JS.
These days I intentionally start all projects with as little JS as possible, opting for Go and HTMX instead. Removing the layers of JS inconsistency and build tools makes my and my agents lives better.
More thoughts on my JS-less stack here: https://housecat.com/blog/the-hugs-stack-hypermedia-unix-go-...
It's scary to think how the hyperscalers will continue to get more and more access into everyones tools and lives under the guise of "AI assistant".
It gives me a glimmer of hope that openness will win. I don't trust Meta as a corp, but they've been doing the a lot of good things with open source, open models, and developer friendly agents.
More thoughts on agent computer architecture here, as I've been building our own open core system for this: https://housecat.com/blog/agent-computer-101
And in this case I hope its true. I've been classifying a lot of email and while OpenAI `text-embedding-3-small` has been very helpful for fast and cheap embeddings, initial tests with Jev are very promising and much more ergonomic.
I put more thoughts here: https://housecat.com/blog/classifying-email
I find pair programming very productive with agentic coding.
Two people (plus one or more agents) have the full context of the plan, execution, written code, automated and manual testing. Both can help drive to the point where it feels safe to sign off on the change right then and there and merge it.
Compare that to traditional PR / code review, where so much of that context is lost. At best the coder needs to spend a lot more time rewriting up a great PR description to bring the reviewer up to speed. At worst the reviewer needs to read lots of AI slop PRs, docs, transcripts, and code to try to make sense of things.
Doing it together then merging the thread and moving on can be efficient.
Im finding a lot of success embedding metadata and data in SQLite files for music management.
Having a spec for a single file with a schema, version, metadata and binary blobs is super easy to shuffle around.
Agents crush reading and writing the data and writing tools around the spec.
All of a sudden things like backup, sharing and dedupe are snapping into place for my music library.
More thoughts here: https://deadca7.com/blog/deadca7-open-music-database-specifi...
Sure the data is correct, but it's obviously way easier for me to read it as a properly rendered table. Then you want to sort, group, aggregate the data. Visualize it many different ways if you will :)
> Make charts of this with dbt Charts. Start with: uv tool install dbt-charts && dct skills intro
>
> build a dashboard of my hiring inboxes: list of candidate name / email / locale, application quality, response age
The one-shot dashboard is surprisingly good.
"Unbundling BI" is absolutely where things are headed now that more people have agents, coding agents, agent computers to help with work.
I'm seeing this all up and down knowledge work tools. I've started treating email as a BI problem -- ETL it from Gmail and and create many different views into it and reports from it.
I just wrote up some thoughts on that here: https://housecat.com/blog/making-gmail-data-fast-for-humans-...
A natural followup is how to better visualize this data in chat. The DBT table component looks like it could help https://docs.dbtcharts.com/charts/tables/
One of the huge value adds of the agent computer paradigm is your agent can also fix and customize its own software.
I’m working on a similar agent computer and having the full source code plus a plugin system is the thing that really made it start working.
Something tells me Meta and Grok bots won’t give you this level of control.
More thoughts at this blog:
I need to buy 10 32GB, but every somewhat affordable bulk option is very suspicious and throttles or fails.
Sandisk is reputable but costs a premium.
The Agent Computer is super powerful, but by definition its easier than ever to build one yourself, and a the result is a personal and private computer.
I know most "normal" people wont want to build their own this but there are still a lot of options that don't involve giving Meta or Grok all your data.
I put some notes on all this here: https://housecat.com/blog/agent-computer-101
Definitely but can't the factory analogy still apply here?
We're now workers on a factory assembly line.
The assembly line still needs people to design and build machines, press buttons to operate machines, verify widgets are correct for their stage of assembly, and verify the final product is correct and ready to leave the assembly line.
Importantly it needs people that spot defects and send things back, and press the "big red button" if something is grossly wrong with the whole process.
The goal is to make this as efficient as possible working with our agents.
I don't think the agentic coding tools are anywhere close to making this awesome yet, but at the same time the best practices of "dev ops" need to be updated to involve agents.
Push to GH, run CI (in GHs relatively slow / fragile runners), poll GH APIs to see status and get errors, make changes. Then repeat.
The optimization is to bring running tests / fixing errors into the core agentic development loop, be much more confident that CI will pass on final pushed changes, then automatically queue / merge the changes.
Then push straight to main? Or do we need GitHub to help manage the queue https://docs.github.com/en/repositories/configuring-branches...
I'm spending a relatively large amount of time waiting for CI to finish running, then clicking a button for an agent to fix failures, then waiting for CI to finish again. Might as well push that down into the core development loop.
Do folks have advice for doing this in practice?
Hooks in the harness? Pre-commit hooks? Different GitHub configurations?
Pretty much every experiment I build now starts with Go, htmx, and SQLite to keep things simple and fast but still responsive.
I put a few more thoughts about this here:
https://housecat.com/blog/the-hugs-stack-hypermedia-unix-go-...
Security is a major concern but I don't see why we aren't already "good enough" with a sandbox VM, separate gateway for secrets and remote service access, and a single tenant using frontier models that have safety checks built in plus not trying to hack themselves.
I put up more thoughts on architecture and security here and would love to learn if I'm missing anything.
I've been doing this architecture on single tenant VMs for like 6+ years now and it has so many advantages for deployments, security and scaling.
Pretty much every new tool and agent computer I set up uses this pattern. I've blogged about it and created a template repo.
https://housecat.com/blog/the-hugs-stack-hypermedia-unix-go-... https://github.com/housecat-inc/scratch