Some of the folks who make things will go on to make things that suit not just their preferences but also those of a small audience.
Some of those audiences will go on to grow and grow and disrupt the big players.
The capital intensive part of software construction is melting away and being converted to opex (payg token costs and your time) and that will blast open the possibility space and lead to a massive new commons.
If the thing was so cheap to create why not open source it!
And if you like someone else’s open source thing but don’t want to take it wholesale why not give it to your agent and say “put the ideas from this onto my thing”!
It’s a new way of thinking about code too.
My wm, shell, terminal, editor, file manager, pop-up menu (dmenu-like) are all pure ruby (including font rendering and X11 bindings). These all started before I started using Claude to improve them, so they're still mostly hand-written, but that is changing.
They're messy, they have bugs and "misfeatures" that works for me but likely would be painful for others.
Like OP, I don't really recommend anyone else use my code, at least not directly, and that is extremely liberating.
Overall, the projects covers the largest surface of what I use beyond the kernel, a browser, and Xorg (I'm so, so tempted, but I think an LLM will need to get a lot further first before I could fit it into my schedule).
It doesn't need to be polished because it's mostly for me. It's okay for them to have bugs as long as they work better for me than the alternatives.
I strongly believe more people should do this. It's both a great learning experience, and it gives you a system that has exactly the features you actually want and use.
And it's only going to get easier to do this.
This is... Not really true? Especially if you are writing just for yourself. These are week-long projects at most to get to a usable state, if you know what you're doing. This is why there are so many text editors and window managers in the first place.
A cybersecurity research company can now spend a small fortune on finding zero days in iOS because of the amount of people that use it. It basically guarantees there will be clients like government agencies willing to pay through the nose for the exploits.
Software made for one might disrupt this business model.
Most software is done after the first or second version and the developers just keep working on it to justify their job; adding features no one needs and just get in the way or make the program worse. It'll be nice when the software I have does exactly what I need and doesn't change until I tell it to change for something I need.
The only feature Macos has shipped in the past 10 years that I actually like is air-drop. Everything else is a PITA annoyance, or as I've found out from upgrading, just bug ridden slop that doesn't work well anymore.
ok seems a lot of fun (for those like-minded), but who seriously want to be dealing with maintenance of everything they use in the long term, in pure assembly all the more?
Not sure I can use it as a daily driver yet, but it would be pretty cool!
I think it's possible the amount of new software that will be written for an audience of 1-10 will be greater in 2026 than in any previous year, and then the same again for many years to come. I also think a lot of this software will be essentially 'hidden' - people just writing this stuff for themselves because the cost to say things to an agent is very low compared with the cost of actually planning out a software design and so forth.
Interoperability will probably be important in the next few years and I wonder if this is something solvable at the agent/LLM level (standing instructions like 'typically, use sqlite, use plaintext, use open standards' or whatever). I also think observability and ops will be pretty important - many people who want personal software but don't care for the maintenance and upkeep.
[1]: https://fortune.com/2026/04/28/nvidia-executive-cost-of-ai-i...
[2]: https://www.briefs.co/news/uber-torches-entire-2026-ai-budge...
I often continue a session on my phone, sometimes with voice. I have buttons for viewing files or following links the agent has referenced, extracted from the stream of text, and I have some buttons for exactly the git stuff I need. I have a button to toggle between yolo mode and normal.
Basically, very simple UI for everything I actually use, easy to use on a phone - and maybe more importantly, no UI for anything I don't personally use. Also all my machines have the repo for the uh, harness-harness, so I just open the tab for it if I need some changes and prompt them into existence and get the changes live.
All this is great, except it enables me to work every waking hour of my life. That part might be bad.
A word of warning: a reliable lock tool for X11 is difficult. You should look at XSecureLock, which uses a multiprocess approach to avoid leaving the desktop unprotected in case of crash. It also implements a number of countermeasure to ensure the desktop stays locked and the locker stays in the front of the display. It's small too, so easy to audit (but written in C).
On this software itself: I’d like to know how this feels to use. It’s so very lightweight. Does it feel categorically different to what we are used to?
One of the things I miss about the 1980s home computers is that they booted into a usable command line in a handful of seconds, from a few KB in ROM. Imagine what today’s HW could do if we’d retained that level of efficiency.
There is part of me that understands the appeal of the all-in on AI and personalized software approach. It's a bit cyberpunk! In terms of open-source software, the downsides outweigh the benefits in my opinion, though. Important principles like community ownership and commitment are absent, and this approach is even radically antisocial. And then there's the inevitable issues with maintainability, to say noting about dependence on big tech companies.
To each their own, but this is not for me.
There are big benefits to using a language that has good static analysis with LLMs.
I struggle to understand why, though.
Would it be possible to share the jsonl files too, like how Mario Zechner shared his chats with the AI, while working on his Pi coding agent?
The other thing is that other people's applications are rarely useful. Their libraries are, the feature description READMEs are, but the software itself is full of attempts at generality that make them overly annoying for me to use. Instead I have extremely idiosyncratic software - anyone else would find it insufferable.
The wild thing, though, is that my software is outrageously useful for me. I can see why Anthropic and OpenAI are (or shortly will be) the trillion-dollar behemoths they are. They are enabling a personal productivity increase of epic proportions[2]. The highly specific functionality also means strange things performance wise. I don't need to use Electron or Tauri or whatever. Instead, my thing is Rust with objc2 and it starts instantaneously. On my M1 Max, it's the fastest text viewer I can start. 100s of megabytes of JSON and it's launching is imperceptible for my tool, pretty-printing is instantaneous, breadcrumbs are live.
Because I can make it do only the thing I want it to do. It can't do other things. I cannot edit or auto-complete or anything. And this is great. Useless to others and fantastic to me.
Likewise, my blog is on Mediawiki (which I like so anyone can edit) but the authoring flow is kind of annoying. Uploading images causes a break from writing, and requires a lot of form-filling that interrupts my thought. So I now have this software that does everything I want: link autocompletion, background image uploads, post-hoc publishing, previews and diffs, built-in Wikipedia search to interwiki link. Who would want this but me? It only brings me pleasure.
What a revolution in software.
0: https://wiki.roshangeorge.dev/w/Blog/2026-04-25/The_rise_of_...
1: https://wiki.roshangeorge.dev/w/Blog/2026-04-30/Personal_Sof...
2: Predictably, I have chosen to use the spare time on leisure
Another thing to watch for is how chatty the internet is about to become. A great many of these apps will hit APIs, ping each other, and so forth.
It's so strange to me that since the 1960s with BASIC then later on dozens of https://en.wikipedia.org/wiki/List_of_educational_programmin... including Logo by Feurzeig/Papert/Solomon there is effort to precisely help beginners program software.
The effort was not to onboard future professional software developers but rather to make the personal in personal computer, or PC, meaningful. It's YOUR computer, you can put YOUR software on it. In fact even pocket calculator do that.
We keep on re-discovering the foundations.
More like Star Trek, we would just ask "computer" to do things, and its machinations (and "software") will be invisible to us. We would just have output to deal with.
I think this would mean a lot of things. I'm sure I can't fathom all of the implications, but it sure makes me feel old! Interesting times ahead.
[1] https://daniel.lawrence.lu/blog/2025-10-22-sriv-simple-rust-...
those in the first camp are having a great time.
those in the second camp (which is how you're describing yourself, and how I'd describe myself) are wary and suspicious.
it is somewhat paradoxical, we've watched/read sci-fi/cyberpunk for years and dreamed of this kind of world. after all, when did you see any members of the Enterprise writing code? they just asked the computer to "write a subroutine" and that was that. what a world!
but here we are, with the craft in danger, not entirely impressed by the idea of "just ask and walk away".
i, too, fear for my loss of critical thinking, raw skills, and design sense, as do i think about being one of the few (in 2, 3, 5, 10 years) that didn't abdicate their cognition, their craft, to the tech overlords.
but i wonder if it will matter anyway. i wonder if "source code" will be a deep abstraction that nobody thinks about anyway, similar to how 99% of us don't care/need to care what the machine code we're eventually emitting does or looks like.
in any case, i'll keep my thinking for now.
Also, reading it is probably not the intended use. It’s probably: “Hey Claude, give me a TLDR of this”
The whole point of this sentiment is that the personal tools wouldn't EXIST due to the time sink needed.
The tradeoff makes sense for a lot of people even if it's not a good fit for you.
I now have tailor made apps with all kinds of bells and whistles that commercial products can’t offer easily ( I fall under non commercial usage which opens a lot of doors ), and that free software might offer, but later.
I have also learnt a lot technically in the process, since I’ve been able to venture into what was for me unknown territory but at controlled cost
I plan to create more such apps in the future. What is certain though is that my cooking app has immediately displaced all the others on the market , because none of the others cater to my requirements.
The production side is indeed of specific interest - most users don’t run production software so I had to think about that one. Tailscale and Cloudflare came in quite handy and there is indeed a market here
I think the instinct that APIs, validation layers, and so on take on a much higher importance is right.. I have a few internal tools that made sense to make libraries out of, and once the first library is good, and a test suite is comprehensive, porting to a bunch of different languages is extremely simple.
Everting that, it's also going to be simple for someone to hook up to this library with custom tooling.
Really interesting period in computing, for sure.
Too bad this is all on the work computer and need to bring it to my personal one but can’t copy paste lol. It’s been thrilling building g and using them and the time from an ideating a small enhancement/ optimization to actually using it is like 5 to 15 minutes away. Soo cool.
I've spent two weeks with the cheapest tiers of Claude Pro + pi.dev+GPT-5.5 (+ some deepseek-v4 via openrouter recently) to create my own bespoke version.
I'm at 90% feature parity currently and surpassed on some levels. For ~20€-ish I've soon replaced a 60€/year subscription service.
I haven't spent a single second thinking about how someone else might run it, it doesn't have logins, security or anything - because I'm going to run it 100% behind a Tailscale node with no external access. The release and deployment processes are exactly how I like it, other people might not. I don't need to care, it's mine =)
A few months ago I did the same with Hazel[0]. That took maybe one evening to get an MVP and a week of casual updates to make it pretty. Now I have my own macOS application that does the exact things I needed Hazel for. It's mine forever and I can add or remove features as I feel like it.
We waste a ton of energy on ineffeciencies in hardware and software today all because we managed to "just go faster".
I, in theory, can plane a piece of wood with a hand planer. But I'll never do it again, we did it at school in ye olden times before the millennium and it was boring then as it is boring now.
I know people who get satisfaction from it, they take one sliver off with the hand planer, feel the wood with their hand and figure out the perfect angle for the next tiny sliver of wood to come out off, repeating the process over and over again.
I, personally, will just feed the damn plank to a mechanical planer with the exact specs of the resulting board set up. I just want the board smooth so I can get to the next step of the process. I'm not doubting the "wood-slop" the machine produces, I can see and measure if it's good enough or not. I don't need to be involved in the process.
We're both making a table, mine will be done faster. It might not be hand-crafted to perfection, but it will hold the stuff I intend to put on it just fine. If I find out it sucks later on, I can make a new one that's slightly better or fix the existing one. My goal was a functional product, not a piece of handcrafted art.
Part of it's that the whole point of going into this industry is that I love coding and have been doing it since I was 8. Part of it is that I'm a control freak and it makes me uncomfortable to have to trust AI generated code. Sure, I already trust interpreters and compilers, but those are much more deterministic, and they don't generally do anything I have to be wary of. Part of it is that anytime I've used Claude to write stuff (using Opus 4.7 via an API key), I've had to handhold it when doing simple things (telling it repeatedly that a given column doesn't exist in Snowflake's task history table and eventually just giving up and taking it out by hand) and had to remove tons of completely pointless Python code it generates. The big difference is that the people in the first camp don't seem to care enough to check. Someone at my company used Claude to write 20k lines of code this past Friday. No way he read and scrutinized all of that in one day.
The other big thing I've noticed is that a lot of the people using it extensively seem to just be spitting out API endpoint after endpoint. Just doing endless CRUD with some light business logic. Yeah, it's not too hard to automate that with AI without any major issues. Hell, back when Ruby on Rails was hot, it was so fast to write those kinds of things with it that I could spin up things as fast as AI is doing now. Full websites or APIs in an hour or two because its syntactic sugar and scaffolding did what AI does with the FastAPI codebases I see these days. You could go from an ER diagram to a working app in minutes sometimes. I don't care that much if that kind of work is automated.
But the incessant “AI was used here, thus is it garbage” is long past time to enter the grave.
Basically, I am prepared to accept that there is a friction that LLMs lubricate away, but what is the source of the friction, and why am I (and a bunch of other colleagues) not feeling that friction daily in our practice?
[1]: And if so, where did we programmers and computer scientists go wrong? Were subroutines and macros not sufficient for automating all of that excess typing? Were Emacs and Vim simply not saving enough keystrokes? Did people forget how to touch-type?
I use a whisper wrapper (also "built for one") for Windows and connect through SSH but it only works well enough because of the laptop's ARC graphics card. I wish I could do that when connecting to SSH from my smartphone.
We're actually going to have hammers designed by blacksmiths, not by comittee.
You must be extremely talented and fast if LLMs make no difference for you.
For people like me though, it's another story: I've been doing this professionally for 25 years and of course, like many, I have been writing custom software for my own use all this time, on personal time. But with LLMs I get better results, faster and with very little effort. And that is the difference between another item in my list of unfinished software that consumed too much of my weekends and a cool utility/toy/useful thing I got after a few fun and interesting chat sessions.
> I find it hard to believe that there is a demographic of people that were yearning to write code, but simply could not because they lacked LLMs.
We didn't lack LLMs, we lacked time and energy.
Yes, because the price is measured in time.
With LLM tooling I’ve churned out idiosyncratic tools that fit my use cases quickly. Takes maybe a day instead of a week. A week instead of months. The fast turnaround changes the economics of writing custom tools for myself.
I also know that these days, for all kinds of reasons, I do not have the time to write the tools I’m writing now without AI. I don’t lack the ability, and I could - it will simply be multi months side projects that I can’t / won’t complete.
I'm a long time ops guy. I script, but I spend most of my time configuring, patch testing, and keeping the low level infra running much of which doesn't require "coding" per say. Infra as code is in the grand scheme relatively new and still not ubiquitous despite what silicon valley would have you believe. I never had a need to learn to code to a level to do many of the things I'd like to see happen and find useful. Now I can make those software desires a reality without having to alter my career, preferred hobbies, or much of anything else about my life.
I write plenty of code at my job, and generally don't have the desire to write more code as a hobby, except in rare cases when the mood really strikes.
In particular I've found that if you have a good infrastructure layer available on which you can deploy then it's much easier to throw small purpose built webtools on there that solves personal problems. Infra here being fixed IP, mTLS reverse proxy, k3s/container, S3 etc. Basic building blocks like that - store data, run app & safe gateway to access it.
If you have that in place then most smaller apps (shopping list, notes etc) is a couple prompts away
This kind of summarizes the whole post for me. I struggle to see how, on a platform that I thought was passionate about engineering, this is gaining any kind of traction. Writing GUI tools in assembly, not to learn, but for whatever other reasons, is nightmarish levels of silly. I get the idea of making software TRULY yours. I get it. This isn't that. Letting an AI agent literally vibe code your entire desktop is not an idea that would come to anyone's mind as more than the punchline of a joke or a side note in a dystopian book.
You're not making software, Claude is. You're not learning anything, and the tools produced are (by design) not really editable.
The ~20 years prior to that we were in a world where you chose to align with either Microsoft's tooling, IBM, or shops providing Unix tooling from proprietary vendors.
I elide a nearly infinite amount of detail, obviously.
What's new now is that you can get your own window manager written to spec in under a week, perhaps much more quickly, not just choose one of a few major window managers and configure it in accordance with the chosen configuration options delivered by the large developer team.
Interestingly, I also converged on the "reverse dictionary" usage of LLMs, in around 2024[1], mostly to indulge in (human) language-learning.
An excerpt from the post below:
``` It is a phenomenal reverse dictionary (i.e. which English words mean "of a specific but unspecified character, quality, or degree"). It not only works for English, but also for Esperanto (i.e. which Esperanto words mean "of a specific but unspecified character, quality, or degree"), as well as my own obscure native language. This is a huge time-saver when learning languages (normal dictionaries won't cut it, and bi-lingual dictionaries are limited, if they are available at all). Even if you are just using a language you are fluent in, a reverse-dictionary-prompt can help you find words and usages, and can also help you find "dark spots" in the language's lexicon. ```
[1]: https://galacticbeyond.com/chat-room-dispatches-intelligence...

For the first time in twenty-five years I’m sitting in front of a computer where almost every program I touch was designed by me. One tool at a time, the off-the-shelf option got swapped out for something a little closer to how my hands wanted to work. (I wrote about the start of this a couple of weeks ago — that post laid out the early swaps; this one is the view from the other side of the journey.)
It’s been a crazy few weeks guiding Claude Code inbetween all the other stuff I’m doing in life. I direct CC, it works while I do other stuff. I get a second or few in between tasks, and I respond. Then off it goes adding features or hunting bugs.
Two suites in a happy marriage: CHasm, the bedrock — pure x86_64 assembly, no libc, the layer that paints pixels and reads keys. Fe₂O₃, the application layer in Rust, sitting on a small shared TUI library called crust.
| Role | Was | Now |
|---|---|---|
| Window manager | i3-wm | tile |
| Status bar / tray | i3bar + conky | strip + asmites |
| Screen locker | i3lock | bolt |
| Terminal emulator | kitty | glass |
| Login shell | zsh → rsh | bare |
| File viewer | less | show |
| Role | Was | Now |
|---|---|---|
| Text editor | VIM | scribe |
| File manager | ranger → RTFM | pointer |
| Email / RSS / chat | mutt + newsbeuter + various web logins | kastrup |
| Calendars | Google + MS web | tock |
| Astronomy panel | astropanel | astro |
| Movies / series | IMDB-terminal | watchit |
What’s left? WeeChat for IRC and other chats. Firefox — the only GUI program I still use regularly. That’s it. Everything else is mine.
Let me get a bit sentimental about vim, because vim was the one I thought I’d never replace.
I started using it in 2001. For twenty-five years, every email I wrote went through vim. Every article. Every blog post. Every line of code, every HyperList, and every book. It was the one tool I would have called part of how I think. The muscle memory was so deep that I’d open random text fields in browsers and ended with typing :w.
Then in three days I had scribe and stopped using vim.
The first commit landed at 00:09 on May 1st. By afternoon today (May 3rd) vim was replaced. Twenty-five years of muscle memory rerouted in seventy-two hours.
Vim is wonderful, but scribe is mine. It’s modal like vim, but missing the ninety percent of features I never used, and carrying the handful of writer-shaped tweaks I always wished vim had. Soft-wrap by default. Reading mode with Limelight-style focus. AI in the prompt without leaving the buffer. HyperList editing with full syntax highlighting and the encryption format the Ruby HyperList app uses. Persistent registers shared across concurrent sessions is a cool feature. None of it revolutionary, but all of it shaped to my exact workflow. And whenever I think of an enhancement I want, it’s just minutes away. It used to be waiting for months or years or forever for some developer to get the same idea as mine and introduce it into the tool I use.
It used to be that writing your own editor, your own file manager, your own window manager, was a project of years. I know, it took me a few years to get RTFM right. A serious undertaking with a serious cost. The economics of it didn’t work for most people, even programmers. You’d touch a piece of it, get most of the way, run out of weekend, and go back to the off-the-shelf tool.
That barrier is much lower now. With Rust, CC as the workhorse, and the fact that the hard problems of TUI programming have been documented to death… the cost of “build the tool you actually want” has fallen by orders of magnitude.
I don’t think this is a story about AI or about Rust specifically. Both helped. But the deeper point is that the gap between “I wish my editor did X” and “okay, here’s an editor that does X” is now small enough to fit inside a few evenings of focused work.
I should say what this post is not.
It’s not an invitation to use my software. Honestly, please don’t. None of it is built for you. It’s built for me — for the way I hold my hands, the way I think about email, the way I want my calendar to render. I’m sure other people would find a hundred sharp edges I’ve never noticed because they happen to align perfectly with what I do.
It’s also not a request for kudos. The code isn’t novel, nor are the ideas. There’s nothing here that hasn’t been done before by someone with more taste, discipline or talent.
What I want to do is show one specific thing: it is now genuinely feasible to make a desktop computing environment that fits one person. Instead of a configuration of someone else’s tools. This is no longer a heroic decade-long undertaking. This is an actual, weekend-by-weekend, “this thing in my life now does exactly what I want” replacement.
The best part of building for myself: the relief of not having to care.
I don’t have to think about configurability for someone with different preferences. And I don’t have to support corner cases I’d never personally hit. Nor do I have to write documentation for users who don’t exist. No more arguing on issue trackers about whether a default is the right default — of course it’s the right default, it’s the one I want.
The editor’s \? cheatsheet shows the keys I memorised, in the order I prefer, with the bindings I think are sensible. Arrogance? Nope, it’s design without committee. The audience is one person. Decisions take seconds.
It turns out an enormous amount of software complexity comes from accommodating users who aren’t you. Strip that out and what’s left is small, fast, exactly-shaped, and a quiet pleasure to use.
If you’ve ever caught yourself thinking “I wish my editor / file manager / status bar / shell just did this one thing differently” and you’ve been told the answer is to write a plugin, learn an obscure config language, or accept the way it is, then consider that the third option is more available than it used to be: Build Your Own Software (BYOS).
You probably won’t replace your whole desktop. I didn’t plan to either. But the satisfaction of having even one tool in your daily workflow that fits you exactly is worth a weekend.
I’m a rabbit in spring :)
"Computer. Run program Riker omega six." <things happen>
Basically you have a repo with web-based tools and a way to deploy them on change. Then you can just quickly whip up (or ask an LLM to do so) any simple tool and it's live within minutes.
Well. You should have seen the look on their faces. I might as well have morphed into the Steve Buscemi meme "How do you do, fellow kids?" They looked at me like I was a total relic or greybeard and said things like "Nah, nobody reads tech books anymore; I learned Typescript from YouTube videos."
They also do a pure play voice input keyboard, if that's your jam or you want to use it with other keuboards: https://voiceinput.futo.org/
Still a cool project, thanks for sharing.
I have wondered about having LLMs output machine code directly and skipping the compiler/assembler altogether. Then you'd just commit your spec/prompt and run it through the LLM to get your binary.
I usually stop reading at the first LLM-ism, but I found the premise of this post interesting enough to keep going - and guess what, the entire article was literally just "I prompt CC to make software tailored for me" blown out to 8 sections.
I think every generation feels like their way of learning was the best, but we all make it work. There was a time when the architects of systems directly tutored programmers on how to write programs.
rust can do that. You can run a hyper stripped down rust that was made for embedded devices specifically because those devices don't have room for a runtime.
As a hobby, normal rates don’t apply, but just not to be misleading on the equivalent cost.
And it apparently can. And very well.
One advantage seems to be that the complete asm file fits easily into CC context window.
well, I can respect that for sure