All Posts

I’ve been in New York the past couple of weeks planning out a new project. Part of that work has been working out how the new thing will be built - what protocol and contract changes are needed and how does it all fit in with the existing system? Ultimately we want to create a specification that we have a reasonably high confidence in, but getting that means working through a lot of scenarios and potential designs which is best done on a whiteboard. We found a really powerful way of using AI to help without winding up with a giant pile of AI slop.

When I started Moolah, I built it as a vibe coded, but “serious” project. I spent time planning features, thinking through design and setting up systems to make sure it was high quality. That takes a fair bit of time and effort, so while it comes together faster than if I wrote it by hand, it still felt like a software project. For many things, that level of engineering isn’t required and you can truly build something that is just for yourself. By other people’s standards it would be AI slop, but because it is perfectly tailored to your needs, for you it’s great. That presents quite a challenge for the wide range of small development shops building high quality, but relatively small software. More and more, people really can just build it for themselves and get exactly what they want. It won’t out sell your product, but if enough people start doing it, you still wind up without any customers.

I’ve switched from Claude to ChatGPT as my main AI assistant. For work I’ve been toggling between the two but I only need to pay for one subscription personally. The current Claude subscription just ran out so now my new best friend is ChatGPT…

I YOLO installed the iOS 27 beta and noticed ads creeping back into apps that have been clean for years. The Pi-hole was still running and still showing blocked queries — the ads were just loading anyway.

It’s been a month since I went all in on using Moolah so time to check in on how its going.

The JSON-RPC API that Ethereum execution clients expose is genuinely awful to work with. Every call is a POST with a jsonrpc envelope, a method string and a positional params array. Numbers come back as hex strings — block numbers, balances, gas, timestamps, all of it — so even after you’ve wrestled the request together you’re piping the response through something to turn 0x1bc16d674ec80000 back into a number a human can read. It does just about everything it can to be hostile to a quick curl.

Tools like Foundry’s cast make it usable, and I reach for them constantly, but they’re still fiddly for ad-hoc poking and they don’t help at all when something other than your terminal wants to talk to the client. What really bugs me is that we designed such a bad API in the first place and then built a layer of tooling to paper over it.

So, naturally, I built another layer to paper over it. exec-rest-api is a proxy that sits in front of any execution client and exposes a sensible REST API, translating your requests into the JSON-RPC calls the client actually wants.

Three weeks of vibe coding the new native Moolah and I’ve gone all-in. All my data has been converted over to its iCloud backend. moolah-server is still running but I haven’t been updating the data there so its getting more and more out of date. At this point, I’m all in.

AI agents like Claude Code and Codex try to be “safe” by limiting what the agent can do to a small set of operations and asking the user to approve everything else. In practice, the approval flow is so noisy and the requests so complex that it provides almost no real protection. We’ve reinvented Windows Vista’s never-ending UAC dialogs, and just like Vista, the only thing it actually trains users to do is click through.

The permission model is fundamentally broken. The fix isn’t a better dialog — it’s a sandbox.

I got Claude to crunch the numbers on the moolah-native project — eight days of vibe coding a SwiftUI replacement for my long-running personal finance tracker, with zero Swift experience. The stats are interesting but they don’t really capture what the experience has been like, so here’s the human version.

I used custom software called Moolah to track my personal finances for many years now. Originally it was written in JavaScript with moolah-server providing the backend and moolah the frontend. This holidays I’ve been vibe coding a replacement written entirely in Swift. It seems like a somewhat useful experiment to learn more about the trade offs of extreme AI usage, so I had Claude dig into the available stats from GitHub and its session logs to compare the two projects and see what we can learn. It’s not a controlled experiment so lots of room for interpretation, but an interesting data point none the less.

The initial version it came out with was a bit absurdly positive about AI, along the lines of I wrote 10x the lines of code in 0.2% of the time - more code is better! But with a bit of prompting and providing additional background it came out with the report below. I’ll write up some more human thoughts on the experience later, but I think the AI-crunched numbers are worth sharing by themselves to set the scene and because the key learnings are genuinely useful.

Claude Code has a status line that sits at the bottom of the terminal showing things like the current directory, git branch, model, and context window usage. It’s driven by a shell script that receives JSON on stdin and prints whatever it wants. I wanted to add one more thing: a short description of what the session is actually working on.

I’ve been using Claude Code a lot lately. It’s become a core part of how I work — planning changes, exploring unfamiliar codebases, writing and reviewing code. But giving an AI agent the ability to run arbitrary shell commands on your machine does make you think a bit more carefully about what’s happening on your host system.

The natural answer is to run it in a container. Not as a security boundary — Claude still needs access to your code, your git config, a GitHub token, and the internet — but as a way to keep all the side effects contained. If it installs random packages, creates temp files, or leaves build artifacts scattered around, that’s all happening inside the container rather than on your actual machine. It also makes the environment completely reproducible and disposable. Something goes wrong? Tear it down and rebuild.

So I built claude-docker to do exactly that.