Just released the tweety v2: https://github.com/pomdtr/tweety/releases/tag/v2.0.0 It includes the revamped tweety cli, which has access to most of the chrome extension api ! I also wrote down a new blog post about it: https://blog.pomdtr.me/posts/integrated-terminal/

Ok last screenshot and I'll stop spamming about my project, this is just sooo fun (and a new spin on the classic "summarize this post" demo)

LLM-powered Method Resolution with Synonllm - I've been experimenting a lot with what new things LLMs have to offer more dynamic languages like Ruby. I'm really hooked on this idea of creating a DSL without an explicit interface, and letting users just call methods semantically and letting the LLM figure it out. You can see kind of what I mean near the end of the video with the FileHandler class example. In that class the method names are much too long for anyone to really want to type, but that extra detail (combined with the arguments) allows the user to use the interface they'd like and have it just work. Also effectively creating method overloading / dynamic argument-based dispatch in Ruby with the help of an LLM...

I posted some thoughts about why Coding agents are a special computational unit that unify not just programs and ML models, but also the programmer. and we should perhaps try to unify Type Theory, Testing and ML Evals into a single framework: https://nilesh.trivedi.link/thoughts/we-need-a-formal-theory-of-agent-evals

If any of you wanted to try tweety, but was intimidated by the install steps, I've significantly simplified them: https://github.com/pomdtr/tweety?tab=readme-ov-file#installation I would love some feedback on them !

New showing: - Service status HTTP API integration in 250 lines of Python (no LLM/UI code) - Voice input mode - Open weight model support from Cerebras (Qwen 3, Llama 4 & Llama 3.3) Extension GitHub Repository

JAMMING TOGETHER FAR APART https://www.pastagang.cc/paper/ This is a paper about live programming, written by many many many people collaborating together in one shared document, with no one credited by name. It's getting submitted tomorrow.

Hey folks, AI-related video 😃 Sorry. The reason I'm thinking about the geometry of this is because I'm hoping it might lead to UI ideas, hence posting here.

Playing with a time traveling WebAssembly visual interpreter, just added the call instruction and call stack

I’ve been somewhat frustrated by limitations in AI agents when it came to both them deciding which web resources might be relevant, and their inability to retrieve private data. If it’s not public, you have to have some method to expose that data to (for example) Claude Desktop or similar - and it has to live in a different silo. Rebuilding all that context time and again is also a pain. With all that in mind, and with some downtime in hand, I’ve put together Sombra - a tool that combines traditional web scraping techniques (the original arc90 readability algorithm) with a modern, authenticated remote MCP connection, consumable by compatible clients. Web pages that you save are stored as markdown and can be organised into collections - and those collections are then available via MCP resources. Scraping happens client-side, so if you can see the content in Chrome, you can save it to your collection. I added screenshot capture too - but haven’t exposed that to MCP yet. I’d be curious if that might be helpful to any of you - it feels like it might be too much when the markdown is available - maybe the visual references could be another resource? About the name, why sombra? I was thinking of sci-fi references such as Peter Hamilton’s u-shadow, or the idea of a “shadow” in Silo - I’d like to evolve this concept further in the future. The stack is Clojure/Datomic on the backend with a TypeScript Chrome extension - the early release is now publicly available. If any of this sounds interesting, I’d love some feedback! It’s one of those projects that scratches a personal itch, and then possibly got a bit out of hand - but having built it, it feels like it would be a shame not to put it out there, in case it helps others. Thanks!

Wasm visual interpreter update: - block, loop, break, break if, i32 comparison ops - function inspector and switcher

I've been exploring combining Reactive UI components (those that separate the state, the methods to update the state, and computed values such as the UI), with the same methods given as tools to LLM-powered agent. The user can then either use the UI as normal or ask the AI to act on the state: with perfect fidelity between the two. I want to see if there is an abstraction concise enough for such components to live on the server instead of the client to enable multiplayer realtime collaboration across many humans and agents. It ought to be possible to accomplish this with much less plumbing.

FYI... Prolog Related References Beginnings of Scheme (prolog-6.scm) to Javascript tranpsiler using t2t and PBP and Ohm-editor, debug session recording

My latest talk, given at Craft Conf in Budapest. There were some technical difficulties, but it should hopefully serve as a reasonable introduction to the virtues of interactive development in Clojure. https://m.youtube.com/watch?v=i_dUvhEIGBQ

TahDah: https://github.com/KTRosenberg/DrawTalking

I wrote a fun little post about something I've been playing around with with LLMs, how might programming change when LLMs can get what you mean without you getting it exactly right: https://worksonmymachine.substack.com/p/the-moldy-cucumber-chronicles

A blog post about my recent work, which is what I demoed a while ago in an online meetup: https://blog.khinsen.net/posts/2025/06/25/hyperdoc.html

This will likely interest the folks here: https://frest.substack.com/p/first-class-models-the-missing-productivity

Wrote up some more thoughts based on the idea I shared over in #C050QK4917D. I think MCP might be the answer to "how" we're going to get the personalized/customizable software that people keep saying AI is going to make possible: https://worksonmymachine.substack.com/p/mcp-an-accidentally-universal-plugin

I'm really happy with this month's FoC bonus episode discussion. Jimmy and I talk about literal values in code (string, numbers, arrays, etc), looking at them as affordances, trying to think about the human-facing elements of their design, as distinct from (but related to) how they serve as syntax, how they get parsed, what they mean at runtime, etc. We also ruminate on literal values in various flavours of visual programming. You do need to subscribe in order to hear the episode ($5/mo), but by doing so you're also supporting the time/effort it takes us to make both these bonus episodes and the main show. So thank you to everyone who does support this effort, and hopefully you find this discussion invigorating.

Finished my live, navigable and interactive visualization of the Observable runtime graph. Works on both Observable and Lopecode. • live: if you add/remove a cell the visualisation update. • navigable: if you click a cell you are taken to the cell source (on observable this opens a new tab and scrolls to the cell) • interactive: as you scroll though birds eye view the detailed visualization expands the dependancies of the focused cell. You can click to pin the current cell. The overall point of this notebook is to provoke the reader into understanding the programming model and ask questions like "what is a viewof" when they try to understand the dependancy graph. Its also useful for authors to find stray dependancies and plan refactors on complex notebook networks. https://observablehq.com/@tomlarkworthy/cell-map

Yo yoo! This is less technical but- thought it would be interesting to put LLM's into a generative 'outline' interface- I always loved workflowy, etc- maybe it sparks some ideas for y'all. Github - Play with it

Teaching computer science concepts (conditional branch handling and / or recursion) using Mondrian for inspiration?

I've stated that CPUs don't implement "functions". In this [article](On Options For Programming https://open.substack.com/pub/programmingsimplicity/p/on-options-for-programming?r=1egdky&utm_campaign=post&utm_medium=web&showWelcomeOnShare=true), I say this again, hopefully in a better way.

F----- o- C----- • Episode 77 • As We May Think by Vannevar Bush [I've had this episode finished and ready to publish for like 2 months now, ugh! Sorry it's so late. Yeah, this was recorded back in, like, April(?) when we were deep in the "rename the community" discussion. Sigh.] We're trying to switch it up a bit between "classics" like this month's paper, more recent work (like the prior, and the next episode — already recorded and releasing soon dammit — a preprint, so fresh), and maybe some weirder things. If there's stuff you think we should read that's relatively short (ideally less than 20 pages), well-written, and arguably relevant (the more "arguably" the better I say!) then I'd love to know about it. No, I'm not going to talk about the content of the episode. Everyone knows it, surely. Surely! Sur… fine. As We May Think was written in the 1940s and, worried about the surge of information complexity in the modern world, imagines how advancements to present technology would allow for the creation of a special machine, dubbed the "memex", that bears a striking resemblance to the Personal Computer of the 80s and later. This paper is often referenced as a good starting point for folks beginning their journey into deeply understanding and reimagining the computer. It's historically significant, it suggests a bit of alt-history, and (rule of 3s) it does other stuff too!

hello i gave a talk about a new live programming language called strudel

I started a Discord for people who're interested in communal computing/dynamicland specifically for people in the Netherlands (and Belgium, I suppose!)

If you happen to be from the lower lands, let me know