Gilad Bracha's blog. A place to be (re)educated in Newspeak
July 23rd, 2026
It's Alive!: AI and Live Programming
In the future, everyone will be able to have their own personal computing platform. In a sense, everyone already does: it's called their brain. It's just slow and unreliable.
At this point, I could begin speculating on cyborgs where AIs are integrated into our feeble minds, but that is not the topic of this post. Rather, the focus here is on a comparatively modest vision:
In the AI world to come, user interfaces, applications and even platforms can be personalized by and for the end user.
One might question of whether the end-user truly wishes to personalize their computing platform. I take that as given.
People will vary widely in what degree of customization they will seek, but the fact that humans wish to personalize their environment is incontrovertible. One-size-fits-all is only accepted when the costs or difficulties of personalization are excessive.
I have been personalizing my software environment for some time. I have my own personal blogging platform, presentation manager, document editor and IDE etc. While that is a very unusual eccentricity today, it is becoming dramatically simpler as AI progresses.
When engaging is such personalization, I argue that both the user and the AI doing the coding benefit from the immediate feedback that live systems provide.
For those too lazy to follow the above link, here's the abstract:
In the near future, multi-modal AIs will interact with us via integrated visual, aural and haptic interfaces, for both input and output. The arena for this interaction is two or three dimensional space - be it a document, a virtual reality room, or (most likely) two or three dimensional overlays over the space around us - augmented reality.
It is imperative that humans should have complete control of these digital spaces. The alternative is to trap us without agency within ever more alluring and immersive spaces, which rather than augment our capabilities, will stultify, stupefy, spy on and manipulate us.
Hence, the spaces must be programmable in a deep way. Everything about the space should be programmable, and the response to our programming should be immediate. In other words, we need a live, self modifying system.
The text above relates to the first half of our argument: users need live programming, because they'll want to see how their suggested changes work without losing any state or context they already have. They cannot be expected to go through a classic compile-build-restart-rinse-and-repeat cycle.
Tangent: Indeed, no one should be expected to do so. Unless you're a software engineer whose mind has been warped by mainstream development practices, you'd never want to do this to yourself.
The second half of the argument is that the AI itself is better off with a live programming system at its disposal. The underlying assumption is that better programming abstractions benefit any code-writing intelligence, natural or artificial.
Tangent: This assumption is what justifies PL research in our brave new world. Making PLs for people is increasingly irrelevant, as traditional coding goes the way of flint tools. And, yes, I realize that last statement is controversial, but I have no time for stochastic parrots.
The Newspeak IDE now integrates AI support, allowing us to test the hypothesis that AI benefits from access to a live system. Here's a video of an early version of Newspeak's IDE-AI integration:
You can, if you choose, check out the AI integration right now. You're already running the IDE, since this post is a live Ampleforth document.
The integration is useful to the human programmer today: AI can explain code, document it, as well as actually write it. It can also explain the IDE tooling itself. One can run multiple AIs within the IDE at once. One can also switch a given AI's focus between specific methods or objects, so that it has the precise context of the code and values you are looking at.
Tangent: The latter feature leverages the structure of IDEs in the Smalltalk tradition, which provide a structured view on code, rather than undifferentiated text files.
Meta-tangent: Ok, all IDEs are in some sense in the Smalltalk tradition, since IDEs originate in Smalltalk. But most IDEs managed to ignore the most valuable lessons of Smalltalk.
You can even set up AIs to observe and critique other AIs and their work. All of this is useful in the here and now, and the details merit their own post.
However, these are all benefits that accrue from bringing AI into the programming process. I want to emphasize the specific advantages of liveness for the AI. They are the same advantages that liveness provides humans.
For example, there's no need for to wait for builds. This blog has discussed the deep problems with builds at length. Of course, there's a lot more to liveness than eradicating the evils of edifices (aka builds). The fundamental advantage of liveness is rapid feedback.
I have encountered numerous cases where an AI harness such as Claude or Codex struggles to predict dynamic behavior that is self evident in the live environment. The ability to evaluate code live, in the context of a specific application, computation or object, to engage in fix-and-continue debugging, to measure performance, to inspect UI layout (especially when dealing with the vagaries of the DOM) - all these are difficult to assess statically. In science, the empirical method has been recognized for centuries; software engineering still tends toward the Aristotelian.
This is not to say that static reasoning does not have enormous utility. I am on record arguing for the importance of formal verification in the AI era. The two approaches are complementary, much like dynamic languages and static type systems. Again, a topic for another post.
The IDE integration is a work in progress. To realize its potential, the system needs to be more robust in the face of the (all too frequent) failures of the frontier model APIs. I should also note that others have been doing closely related work integrating AI and live IDEs - notably Glamorous Toolkit and Visual Age Smalltalk (see this video). Apologies to others I may have overlooked.
The usefulness of live programming to AIs holds independently of the claims about end-user programming and platform customization. Still, its significance as an enabler of user autonomy seems to me to be the most important aspect.
Conclusion: even as traditional line by line coding vanishes, live programming systems have a great role to play.