tritondev
Joined 1 year ago
Karma
13
Submissions
13
Member since
Nov 16
Recent submissions
Comment · 4 months ago
Comment · 1 year ago
The project has 65k lines of code (plus another 11k of tests and tools), but a lot of the heavy lifting was done by LLMs with me providing them detailed problem statements, reviewing their work, and then having them fix/improve what they'd done. At this point I'd guess LLMs have built about 80%-85% of the code and I've built the rest. I've had to keep the architecture clean, however, because the LLMs have struggled with that.
I built the Metaphor prompting framework first, then worked my way up from there.
The project has been running for about a year, and I probably averaged about 40 hours a week, so something like 2000 hours so far.
Comment · 1 year ago
The concept that LLMs will need to have strong isolation and that this is done with the same sort of diligence normally applied to virtual machine design makes a ton of sense. It's exactly the same reason we enforce such behaviours in operating systems.
I took a first pass at enumerating some ideas a few weeks ago: https://davehudson.io/blog/2025-08-11
My thought was to try and define this in a slightly more concrete way by thinking about analogies between the way LLMs operate and more conventional OS processes/tasks.
Building some of the core abstractions isn't too hard - I already have one that unifies the chat and tool use interfaces for 8 different LLM backends. That lets tool approvals be managed in a centralized way. I've not yet implemented a capabilities model but it feels natural, and I worked with one back in the 90s (VSTa if anyone is interested in historical OSes). A key part will be to allow one LLM to delegate a subset of its current capabilities to another (I already built the delegation tooling)
Comment · 1 year ago
I'll put one out :-)
Comment · 1 year ago
Definitely not a VSCode fork - it's written in Python for one thing :-) In fact it has very few package dependencies other than the standard python libs - just PySide6 and qasync to allow me to use the Qt widget set, and aiohttp to implement the client side of the REST interfaces to the AI backends. The only other dependency is on the m6rclib I wrote a few months ago - that's a prompt compiler engine and that has no dependencies either.
The "coded by AI" is because the AI did the bulk of the code generation leaving me to focus on the design, improving the structure, etc. There are a few places where I did more of the design work (e.g. the structure of the parsers and lexers used for syntax highlighting), but I had the AI do much of the refactoring.
To keep the AI on track I designed a lightweight language, Metaphor, that keeps it focused on the intent of what I want. There are currently about 1300 lines of Metaphor, describing the user-visible behaviour of a 15k lines of Python app.
Of course, I watch the AI pretty carefully to ensure it doesn't do weird things but give it the right context and it's pretty amazing to watch (there's a video of me having the AI build the JSON lexer/parser yesterday morning up on YouTube: https://www.youtube.com/watch?v=E-1XbJkHwHQ). For transparency, I did find one bug in the 300 lines it coded in the video :-)
The idea is the AI writes a functional transform for a file or editor buffer of whatever form it needs.
Brief LinkedIn note with an example: https://www.linkedin.com/posts/davejh_its-a-great-feeling-wh...