It would be cool if you could rebase a conversation with an LLM after editing one of the earlier prompts. Just like `git-rebase`, but over a chat log. This would allow edits to trickle down to all subsequent responses.

Vibed a little TUI to configure my Obsbot webcam under Linux, since there is no official software. Works great!

The major downside of vibe coding is that you end up with 1) much more code, and 2) badly factored code, which leads to 3) very poor token efficiency when making changes. It probably still all works, but the cost of maintenance and change grows much faster than for manually written/reviewed code.

LLMs are incredibly useful despite writing poor quality code, but we need better code review tools.

Progress on my TUI diff tool 👀

This is the right policy. The problem is not AI in itself, it's low quality contributions, which there are more of now. That is the root issue and that's what should be addressed, not the tools used by the contributor. github.com/rust-lang/le...

New #comics acquired!

This is what the output of `git show` should look like. I've taken some of the work I did on terminal-based diff rendering for @radicle.dev and made it work as a general git-diff tool.

Good engineering + clever use of LLMs will become unbeatable. We're just getting started.

Trying out autoresearch to reduce compiler code size. Not bad, let's see how much of it I'll keep.

An AST editor is always how I imagined the future of code editing -- text is just the visual representation of it, but the editor should operate directly on the AST. This also makes things like code formatters redundant. This is directionally right: ki-editor.org

Radiant is open-sourcing its compiler toolchain and launching code.radiant.computer today.

Some more details about compiler bootstrapping, fixed points and trust. Though originally the fixed point was reached after 3 stages, it is now reached in 2!

The problem with agents is they don’t know what they don’t know. We humans do have an intuition for it.

The Radiance compiler has reached a fixed point. This means it can now compile itself and generate identical output to itself.

user> just fix all the bugs I'm tired and going to bed. llm> ok, I'll fix all the bugs. ... 8 hours later ... llm> Wait, the issue might be... Actually... blah blah llm> But wait! Let me just.. blah blah blah user> I'm going back to bed.

🪵 A new log entry was posted: "A.I. and the Future of Computing" radiant.computer/notes/ai-and...

1. Writing a compiler in C to compile Radiance to RV64 ✅ 2. Porting the C compiler in (1) to Radiance ✅ 3. Compiling the ported compiler in (2) with the compiler in (1) ✅ 4. Compiling the self-hosting Radiance compiler (3) with itself 💥😵‍💫

I can't think of anything more soul crushing in the UX space than trying to make a keyboard work on a smart phone's touchscreen. It simply is the wrong interface. In fact touchscreens are the wrong interface for most things. ios-countdown.win

Yes, this is a web-based Git repository browser created from scratch in a couple of hours using an LLM.

Great talk about hardware/software co-design and why serious software developers should think about hardware. This is one of the core principles of @radiant.computer h/t @lorenz.leutgeb.xyz www.youtube.com/watch?v=v0Jj...

Incompatibility allows true progress.

🪵 A new log entry was posted: "Radiance Intermediate Language" radiant.computer/log/011-radi...

"On Being a Computer Scientist in the Time of Collapse" is a really excellent and thought provoking read. I'm one of those optimists that is heavily criticized in this essay. web.cs.ucdavis.edu/~rogaway/pap...

‘What Remains of Edith Finch’ puts every other game I played recently to shame. What a crazy experience.

I've been in the deep end on the Radiance AST -> IR lowering pass, but I'm starting to see the light of day. I did things a bit differently this time in terms of code production, and I'm not sure it was worth it: I had Claude generate this compiler pass from scratch, which resulted in...

One of the greatest skills in software engineering is to know how much code is needed to implement any given feature. This lets you immediately tell, without reading the code, whether it doesn't account for something (code too short), or it's overcomplicating the solution (code too long).

Writing code has become a lot faster, but understanding code hasn't. What can we do about that?

The biggest problem with vibe coding is understanding the state of the code base at any given time. The reason to write code yourself, or to review all the code written by an agent is to have a clear mental model of the program. This is still a major bottleneck.

Interpreted languages have an edge in multi-agent workflows, because agents can't break the build for other agents. Compiled languages have an edge because they created more effective agentic loops. Languages with optional type-checking probably are the best of both worlds in this respect.

The reason leaving at 5:00 PM sharp rubs people the wrong way (including myself) is that it can imply a bunch of things that are not condusive to doing good work, especially in software development. It has nothing to do with working overtime...

"Can I finally start using Wayland in 2026" -- that's 18 years after release, and the answer in this case is "no". This doesn't raise any eyebrows because we've become used to software inertia. @radiant.computer will change this. michael.stapelberg.ch/posts/2026-0...

"Technical debt is the pollution of the digital world, invisible until it chokes the systems that depend on it" Great read. chrisloy.dev/post/2025/12...

Radiance IR (RIR) tentative syntax. Below is example code for a simple loop that sums numbers.

Software can afford to be broken because it can be patched over the air, therefore most software is in a permanently broken state. ¯\(ツ)/¯

Here's a list of things I've saved countless hours on by using an LLM: 1. Writing tests for specific functions or branches 2. Documenting code 3. Finding the bug (regression) that causes a test to fail 4. Refactoring: renaming things, moving code around, changing function signatures, etc.

Choosing an intermediate representation (IR) for Radiance is tricky — every language seems to do it differently, and many languages have multiple IRs, especially those that target LLVM. Rust has MIR, Zig has ZIR, Swift has SIL.. I think I should just start simple and see what design falls out of it

Just discovering Gleam (the programming language) and really like how sensible and minimal the language design is! For example, there is no distinction between sum types and product types; they make it work by allowing field access without destructuring in simple cases. Very cool. gleam.run

What would an OS with built-in version control at the file system level look like?

"Don't re-invent the wheel" is why our software has shit performance.

There is something really freeing about coding LLM agents: they let you change your mind. Previously, I'd avoid large mechanical code changes that weren't absolutely necessary, due to how much time it would take. Now, changing my mind about a certain design decision is no big deal.

This was a lot of work, since it exposed several bugs in the C code generator and type checker that I had to fix, all the while ensuring parity between the C and R' code! Making a compiler self-hosting is hard when the bootstrapping compiler isn't stable yet, but I'm eager to not touch C anymore!

When your BSS section is 17GB because you thought "eh, I'll think about memory allocation later and just use static memory for now" 😵‍💫

Sometimes you have some really serious design problem to solve, but you've got this itch to do something totally distracting and not relevant, like implement a Lisp, or some actor-based concurrency, and you start to convince yourself that this is actually the solution your problem, but it's a trick!

Thinking about how to reduce the complexity of separate compilation.. 🤔

If there's a promising alternative to OSI licenses, I'm ready to adopt it for the entire @radiant.computer platform. One of the reasons I've held out on putting any new code out in the last couple of years is because I don't want it to benefit my enemies.

I am so down for this -- I've been releasing software for 20 years under OSI-approved licenses, with the hope that this will empower individual users; but those who end up benefiting the most are likely Big Corps. We need a post open-source movement and better licenses.

🪵 A new log entry was posted: "R' language design progress" radiant.computer/log/009-r-la...

Working on the module system implementation in R', getting the module graph setup. package = compilation unit (equivalent to rust "crate") module = namespace within package