The Emacsification of Software(sockpuppet.org) |
The Emacsification of Software(sockpuppet.org) |
A month or so ago, I had claude write a visualizer for some data. There is an existing python viewer, but it bogs down & is painfully slow at the scale I need. So I asked Claude to port it to a compiled language. After 2 hours of iterating, I had the tool that I wanted.
Note that its throwaway, dumpster fire code. But for a one-off tool like that, its fine.
Edit: Sure there is some small overlap here, but it's really not comparable and definitely not like the way the author describes things. User personalization in Emacs has normally been on a much smaller scale than rewriting entire packages. Configuration is generally smaller tweaks or things on top of existing packages because Emacs provides cohesive extensibility to the point that it often doesn't require "rolling your own." Most packages are already extremely configurable and tailorable. You don't magically get that sort of environment with LLMs. Emacs is much more cooperative/generalized.
The scale and type of custom/personalized software we're seeing now with AI is completely different from how things have been in Emacs. I'm not saying that's a good or bad thing (I think it's both), but it's very different from Emacs and definitely more comparable to something like vim/neovim where (in part just because of the sheer popularity) you constantly have people "rolling their own" packages and a billion versions of everything. Even that is not a great analogy. This is something completely new.
Specifically the idea that people generally just ignore existing versions of packages and make their own has never been the case, especially compared to other editors (even VSCode).
> There are popular elisp packages lots of people use. But except for Magit, nerds are alarmingly apt to replace them with their own shinier versions (and then to show them off, transitioning to the spore-forming phase of the elisp lifecycle). Everything in Emacs is malleable.
> Until now, the Achilles heel of Emacs culture has been that, except for Magit, its packages tend to be wretched user experiences. Ugly, slow, and discoverable only after inflicting years of elisp cortical injuries on yourself.
I have never heard of such an editor, and the name is exquisitely unsearchable. Even if I explicitly try to tell the search engine that I'm looking for a text editor that's a variant of vim, I just get results about using vim on a Raspberry Pi.
But you mentioned multiple variants thereof, in the context of a thread about Emacs.
It's highly disingenuous to suppose that this doesn't count.
My own Obsidian.
Obsidian is great, BUT I want some specific features + stuff to make my own. I already have the .md files on my personal server and I already have local LLMs that perform actions on them for sorting, tagging etc. I already build custom web apps to view these markdown files (like my own janky database). Obsidian as the main client for editing them is fine, but I really want to make my own custom to address a few specific needs.
AND now? I'm going to fork your app + customize it to my needs (if you're okay with this of course). I'm excited about this, so thanks a lot for pushing me to take the plunge!
If this is the starting thought, I don't know how you wrap back around to publishing and advertising the generated code.
Either you create the best possible mac markdown viewer and should share it as that, orthogonal to any statement of AI use. Or you're just adding to the noise of tools available online. Where other people should ignore your work, and go slopcode their own markdown viewer.
"With LLMs you can just make your own".
I read dogleash's comment as emphasising the bad parts of that. If everyone's just sharing their half-baked slop, it becomes harder for people to discover the good programs which are worth using, and harder for those quality programs to get social proof (or good direction).
I think what we’re seeing quite a bit lately is developers are stepping back a bit from the development themselves because the AI does much of that part. So they’re managing the products for themselves, even when they are the only customer. The best people at doing this are going to be people who really understand what needs to be done, because that’s what the product manager/product owner/business analyst/customer liaison type of role has always been.
My .emacs file is init.el which is actually init.org, which isn't an Emacs file but a literate program that's half a guix installation script and half a regular .emacs file.
Also kill all markdown. Replace it with xml or better yet SXML.
And as per the general theme of the post anyway: whatever. Because you can just work around it, whatever it is, by cobbling together some code, one way or another.
Right.
In a broad sense, programming is about managing complexity/information. Constructing interfaces/abstractions in order to choose which details are useful for an interface (& which can be ignored).
The 'magical' parts of LLMs is being able to get useful output from unstructured/messy inputs.
It's kindof surprising that this has an impact on programming: it changes a lot ("write me an app that does this" becomes feasible for 'small' things), but in some sense, the fundamental problems remain.
Not related to the main point of the article, but I find reading long form contnet in a mono font much easier.
(Please excuse my self-promotion.)
“Emacsification” clocks that everything now works this way, not just baroque text editors.As a verb, "to clock" means something like "to notice" or maybe in this case "to highlight, with specificity".
For example, in this particular case, a native app limits you to viewing Markdown on your laptop. If you work in a remote Linux VM, you can render to HTML and view Markdown on any device that has a web browser.
It's authenticated by default, making public websites is easy too.
The "0% product hunt, 100% show and tell" bit is one of the benefits of an ecosystem with painfully high upfront entry costs.
Does anyone know of an active forum of any kind (discord, reddit, phpbb, mailing list, whatever) for people who are building personal applications like this for love of the game, which takes hardline stances about desirable vs undesirable motives and behaviors, and enforces high entry/participation costs in exchange for unusually low quantities of transient grifters and self-interested status seeking by day-old accounts?
> monospaced and thus fatiguing to read.
Monospaced text is fine. I don't see how people who read code (and code comments) all day care that strongly about this. Plaintext is king
I have my Obsidian vault synced to Google Drive, and it’s completely impossible to just look at the files in it via the web interface. iOS support is also more than lacking.
So I asked my agent to write typst, ran "typst watch", and now I can look at a nice pdf file. it even auto-refreshes when the clanker changes it.
I don’t think we’re at the point where any random stranger on the street can get Claude to make a perfect Electron app for their use case.
Why should I use your software with oceans of padding and unlabeled hieroglyphic icons from which you've removed 99% of features? I can just do it myself now. Ostensibly, yes, the software is "worse" in some technical sense, but better in the ways that actually matter: it can be used it can do a job. It no longer exists as a stage for the author's minimalism fetish or as a vehicle for some pointless middle-manager's promotion package.
Software is a tool, it's supposed to be useful and do tasks to help the user. We've spent so much time, money, and brainpower this past decade making software as unusable and unhelpful as possible. Is it any wonder that when computer literacy has hit a huge low that people immediately and with gusto jump onto the "make your own software the way you always wanted it to be" machine?
Whether good or bad, this is a pretty natural reaction to the previously-modern state of software. The industry decided to only publish software that can only be used One Correct Way, and physically prevented any use other than the single happy path by stripping out any feature that wasn't absolutely critical. If a user wanted something other than the author's personalized emacs file, fuck them, that's their problem. We decided to only publish UIs that cannot be understood by humans and HOW DARE anyone suggest ultra-minimalist UIs that are 85% whitespace are bad, what are you a Luddite?! And the huge crew of self-entitled "well just fork it if you hate it so much" crew.
We did this to ourselves. We made software exclusive, elitist, and are shocked when the masses go "okay, I'll make my own"
But...I like MDV.
But the beauty of this moment is that if you want a really good SwiftUI monospaced Markdown reader, you can have it before dinner. This is exactly what I'm talking about. You have an idiosyncratic personal preference, and it's now reasonable to expect software to shrink-wrap around that preference.
Also, are browser text area inputs monospaced by default for everyone? Or did I configure that for myself long ago and forget? If it's not just me, maybe the "reasons" you're alluding to are not so obvious. Anyway, I have no trouble at all reading the long comments I type into text areas.
And more power to people for embracing agency :)
You underestimate the number of HN users who are reading this site in their terminal. ;-)
Legacy decisions as a remnant from a time when taking more space on paper cost pages and therefore resources, remaining as a default from centuries of inertia in how text is printed?
The whole entire point of computers in their best light is changeable software, the whole point should be "let people read how they want to."
And why did you author them in LaTeX if you think reading in monospace plaintext is fine for everyone?
But seriously: you do you. There are people who code in proportional typefaces and they're as baffling to me as you are right now. Let a thousand Markdown viewers bloom.
The legacy is proportional, at least in Latin script and its ancestors. Handwriting was proportional, of course, and so was Gutenberg's printing press. Books and newspapers have virtually always been printed in proportional type.
In Chinese and Japanese, monospace is legacy in both handwriting and print... and also still universally used today. All Chinese and Japanese text is monospaced by default. Billions of people are getting by just fine reading monospaced prose.
I don't really know where this conception that monospaced is somehow objectively harder to read is coming from. Actually, this is the first I've ever heard of the complaint. I can't help but wonder if you've been subjected to some very bad monospaced fonts in prose or something.
Software production is now so easy that everything is a .emacs file (pronounced "dot emacs" btw): meaning, each individual has their own entirely personal, endlessly customizable software cocoon. As tptacek says in the OP, it's "easier to build your own solution than to install an existing one" - or to learn an existing one.
Another good analogy, not by concidence, is to Lisp in general. The classic knock against it—one I never agreed with but used to hear all the time—is that Lisp with its macros is so malleable that every programmer ends up turning it into their own private language which no one else can read.
Tangential to that was Mark Tarver's 2007 piece "The Bipolar Lisp Programmer" which had much discussion over the years (https://hn.algolia.com/?query=comments%3E0%20The%20Bipolar%2...). He wrote about the "brilliant bipolar mind" (BBM) - I won't get into how he introduces that or whether fairly or not, but it's interesting given how "AI psychosis", in both ironic and unironic variants, is frequently mentioned these days.
From Tarver's article (https://www.marktarver.com/bipolar.html):
The phrase 'throw-away design' is absolutely made for the BBM and it comes from the Lisp community. Lisp allows you to just chuck things off so easily, and it is easy to take this for granted. I saw this 10 years ago when looking for a GUI to my Lisp [...] No problem, there were 9 different offerings. The trouble was that none of the 9 were properly documented and none were bug free. Basically each person had implemented his own solution and it worked for him so that was fine. This is a BBM attitude; it works for me and I understand it. It is also the product of not needing or wanting anybody else's help to do something.
Sounds pretty 2026, no? He goes on:
The C/C++ approach is quite different. It's so damn hard to do anything with tweezers and glue that anything significant you do will be a real achievement. You want to document it. Also you're liable to need help in any C project of significant size; so you're liable to be social and work with others. You need to, just to get somewhere. And all that, from the point of view of an employer, is attractive. Ten people who communicate, document things properly and work together are preferable to one BBM hacking Lisp who can only be replaced by another BBM (if you can find one).
---
When production is so easy, consumption becomes the bottleneck [1], and suddenly sharing is a problem. This is why the Emacs analogy is so good. A .emacs file is as personal as a fingerprint. You might copy snippets into yours, but why would you ever use another person's? (other than to get started as a noob). You just make your own.
The more customized these cocoons get, the harder they are for anybody else to understand—or to want to. It isn't just that another's cocoon has too high a cognitive cost to bother learning when you can just generate you own. It's also uncomfortable, like wearing someone else's clothes. The sense of smell somehow gets involved.
I would call this, maybe not AI psychosis, but AI solipsism.
In software it's fascinating how configuration management (that boringest of all phrases) is becoming the hard part. How do you share and version the source? What even is the source? Is it the prompts? That's where the OP heads at the end: "share it somewhere — or, better yet, just a screenshot and the prompts you used to make it." But when I floated a couple trial balloons about whether we might use this for Show HN—i.e., don't just share the code you generated, because that's not the source anymore; instead share the prompts—we got a lot of pushback from knowledgeable people (summarized here: https://news.ycombinator.com/item?id=47213630).
These dynamics can only be what's behind the pipe-bursting pressure that Github has been under. What a Github successor would look like is unclear, but as a clever friend points out, there will have to be one. Projects and startups along these lines are appearing, but we seem to be in the horseless carriage phase still.
Even more importantly, what happens to teamwork? If we are all a BBM now—or rather, if we all have personal armies of BBMs, locked in a manic state, primed at all hours to generate things for us-and-only-us—how do we work together? How do cocoons communicate, interoperate? What does a team of ai solipsists look like? It sounds oxymoronic.
My sense is that a lot of software teams, startups and so on, on the cutting edge of AI-driven / agentic development, are currently contending with this, not (only) philosophically but practically, e.g. how does my generated code compose with your generated code. With these frictions we presumably end up giving back some portion (how much? who can say?) of the productivity gains of generated code [2]. One would expect such effects to show up over time, as the systems being built this way grow in complexity and maintenance/development tradeoffs become things.
I don't see many talking about it publicly yet though, which is a pity. No one wants to be the first to stop clapping and sit down during an obligatory standing ovation, but it's a bummer if you can't (yet) tell interesting stories about downsides and instead have to pretend that this is the first free lunch, the only downsideless upside that ever existed. It makes the discussion performative and probably slows evolution, since the experiments, ironically, are happening in silos.
These are the people doing the most serious and real and advanced work with the new tools (edit: I mean in the field of software dev), so it sucks if all talk of downsides is left to the cynical/curmudgeonly contingent, who for whatever good points they may, er, generate along the way, are obviously wrong about AI having no value for software dev. It's easier to talk about AI wiping out the human race than, say, bug counts going up or productivity levelling off after a while.
Mostly I just want to know what's really going on! and how people are dealing with it and how it is developing over time. Do I have to like go to meetups or something?
[1] That's why a recent paper used the title "Easier to Write, Harder to Read" - https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6726702
[2] Ran across this saying the same thing, a bit more strongly, the morning after I posted the above. https://x.com/fchollet/status/2054917282015445076. Maybe we'll get the conversation after all!
Same deal with a lot of this software. I guess there's some "taste" to it, but mostly what you care about are the ideas and the "recipe".
Also, you should just do a monthly "Vibe HN" thread.
> you should just do a monthly "Vibe HN" thread
It wouldn't stop people from feeding them into the Show HN stream, which is the problem. If we had a good enough way to tell them apart, we could factor them into two streams, but we don't yet.
1. erring on the side of sounding cooler
I can install WhatsApp in a few tens of seconds. You most definitely spent more time than that writing this comment.
Would you mind sharing a video of you building a custom WhatsApp in less time? Not even starting to think about getting other people to talk to you on your instantly-built messaging solution...
We're still waiting for tptacek's DIY WhatsApp alternative since he believes that it's "easier to build your own solution than to install an existing one".
That must be one of the most silliest comments I have ever read, and the worst part is even the moderators agree with the statement.
AI psychosis is indeed real.
> I can install WhatsApp in a few tens of seconds.
But do you now have an insanely deep knowledge of WhatsApp (i.e. what serious "learning" means)?
One example of teamwork is how the programmers and researchers worked together to build the UNIX SYSTEM (https://www.cs.dartmouth.edu/~doug/reader.pdf). It is not a product but an environment optimized for building tools and solving practical problems with tools written in C (while BBMs were busy with Lisp in Boston .;-)
C++ is a totally different story and you need an IDE for that.
I can concur with that thought direction. We used to pair and group-program on my team, we have a "Zoom office". Now it has become "let me take this ticket and feed it to Claude, you try the same thing with Copilot, and then we compare the results", or "I'd make a PR with my clunker, you use yours to review it". This shit honestly feels almost pointless. The pair-programming is absolutely dead. Who wants to watch me run several agents, trying to fix multiple things in different work-trees, while I'm juggling them around and fixing inconsistencies in my agents.md?
I've been pushing the idea of building a self-governing, fully autonomous cloud pipelines so we'd stop playing "stupid tokenomy" games, and it seems my management is just quietly trying to "keep it down", because I think there's a simple understanding - the moment that shit proves airworthy and actually can fly, a bunch of them are guaranteed to lose their cushy seats.
That’s a joke. But it tells something about consumption problem.
Other thing is that a lot of software is useful only if lots of people use it over long periods of time. If every corporate employee vibe codes his thing then maybe it is better if they stick with Excel.
It works, it’s powerful, and certainly one way to answer the question you pose. I would argue it’s the optimal answer, it’s an answer to RPC, REST, and MCP at the same time, but it’s definitely an example of an answer and approach. In any case it is a good question and something I’ve given a lot of thought to.
Unfortunately in the age we’re in now there’s something lackluster in sharing any solution or design you have. Though the architecture and design of what I’m describing came 0% from AI everything is assumed to be and therefore unimportant? But it is the direct answer to your question so if anyone’s curious lmk.
The tendency for the Lisp community to self-segregate into these bubbles is something that's perplexed me for years. You noted that you don't agree with it; I'd in be interested in why. I do agree with it, in the sense that this phenomenon does occur to an extent, and certainly to a larger extent in Lisp compared to other languages. The part I don't agree with is that this is a universal deal-breaker for Lisp. And there's still plenty of cooperation and sharing in the Lisp community. Emacs once again is the prime example. Yes, every .emacs is as unique as a fingerprint. But the reason GNU Emacs refuses to die is precisely its wonderful ecosystem of extensions that have in fact been shared and maintained by a wider community. And this ecosystem is in part possible because GNU Emacs is devoid of any sort of boundary between application code and extension code, which is a philosophy that can be traced back to the LISP machine era.
It's also interesting to tie this in with RMS(the author of GNU emacs, what a coincidence!) and his stance on Free Software really being about every individual user being free to modify the software they run. Of course, the deep implications of this philosophy, and its implementation in Emacs and other Lisp software, are clear to me, because I'm a Lisp programmer, just like RMS. And the Free Software movement originated in a time when most people with access to a computer had at least some amount of familiarity with programming. But as computing has become mainstream, RMS' original vision has morphed, and the focus has been on the importance of the wider community being able to modify software. And that's certainly important. But it's not really free software in the original sense unless you happen to be a programmer. Most software users today are not programmers and likely never will be, so regardless of how the software they're using is licenced, they're not really free in that original sense, are they?
Then LLMs showed up. And suddenly, I can see on the horizon a revival of free software in the original sense. And yet it feels quite far away. For this to become reality, we need a lot more than what we have currently, which is a pretty damn good search engine/meme generator for the "normies", and a pretty damn good boilerplate generator for the coders. I think we probably need an entirely new concept of what software even is. I think we probably need new foundational research. I don't necessarily see a role for current LLM architectures in this. I feel more like current SOTA is scratching at the surface of the real deal, and it may take a few years to understand how to make foundational progress. Maybe we even need another AI winter to force the capital expenditure into other avenues. Certainly we need foundation models that are open in all possible senses of the word. Being tied to proprietary, heavily censored blob running in a giant datacenter is a non-starter.
It seems like the majority of people in the field have some intense tunnel vision about LLMs and transformer architectures. I'd love to see more variation there. I know Lecunn is doing some unique stuff. I can't pretend to understand whether it has legs, but I applaud the effort. Certainly we need to address the issue of energy expenditure, the absurd amount of data and training iterations required, and the lack of online learning. Human brains are vastly superior at all 3 of those metrics. So like, how about addressing that instead of just building ever larger sandcastles filled with nvidia chips? Anyone?
Those are some of the thoughts percolating through my head. I can't really figure out what to so with them. Maybe someone else can. Please? Thank you.
https://news.ycombinator.com/item?id=47393437
I would add to that a few more open questions that I haven't seen addressed:
- As more engineers (and non-engineers) pick up coding agents, everyone is authenticating multiple MCPs, creating an n * n explosion of complexity that is impossible to centralise. Multiply this by the number of distinct coding agents for every platform and visibility is very tough. A lot of platforms also don't support scopes so you can't enforce safety short of a network proxy I suppose
- For non-developers mainly, lacking mental models such as <agent> for Y desktop app does not imply that there is a local LLM running on your machine. I suppose it's a question of trust and education versus starting conservative and progressively onboarding where we're more of the former.
- We talk a bit about the idea of sharing prompts but that fundamentally a prompt does not in itself contain quality. I've had internal tools I've made where it's mentioned that Claude made it when I mean, yes to a degree but I did many iterations using my own taste to refine things and held opinions about how things should operate. Giving someone a prompt won't inherently guarantee anything of quality. I often think about the idea of ie; give a screenshot of Github to an LLM but in a way, you're saying to create a clone, not of what exists today but is a dead echo of the design taste and choices made years ago that persist today. You can create things cheaply but without taste and good judgment, how can you continue to evolve it in a way that isn't like that draw the rest of the horse meme.
- I personally wonder about tokenmaxxing stories you hear about from other companies and like, logically what happens to glue roles? Does someone like a Microsoft just stack rank on token count and fire those who actually get work done? I suppose they already hollow out knowledge anyway so maybe it's nothing new.
- Definitely the thing with internal tooling where eventually you generate so much that you fundamentally have no mental model. It's fine for non-critical stuff and I'm kind of coming around to the idea that it's actually a better position to have no idea of the code and a strong "theory" of how a thing should work than it is to fully understand the code and have zero "theory". Ideally both of course.
Anyway, this isn't a comprehensive ramble but I've also been a bit disappointed that there hasn't been more talk about the second order effects. Many things can be true at once where you can see value in LLMs while still being critical of them and the whole DC situation ie; Colossus 1 etc.
seriously?
* Podcast apps
* Music listening apps
* Feed readers
* Bluesky clients
* Note-taking apps
* Desktop bookmarking/read-later apps
* Chat and instant messaging
* Time trackers
* Recipe managers
These are all things that you can get better-than-replacement-grade results from Claude on --- not necessarily the best, not necessarily the most globally competitive, but certainly an application more closely tailored to exactly what you want it to do for your own idiosyncratic work style.
Music.app is a miserable experience, and I can just tell as I use it that it's miserable trying to serve me. But Apple long ago factored all the meaningful bits out of Music.app into MusicKit. Why am I still using Music.app? MusicKit is the real product now. This is new.
But to be honest, my time using Emacs didn't teach me to "build personal software". My Emacs set up was extremely brittle, and it was a nightmare when I tried to use it across Windows & macOS. My university project was written using an unholy combination of org-mode & some workflow to create a beautiful LaTeX file, and I couldn't tell you how to recompile it (if I were to try, I'd probably get an LLM to literally translate it to LaTeX).
I want my life to have as little maintenance as possible, and making my own software for everything isn't always compatible with that.
[0]: A rewrite of a NETFX application in Rust, simply because the 20 minute installation time irked me: https://github.com/bevan-philip/wlan-optimizer
1. <https://www.winestockwebdesign.com/Essays/Lisp_Curse.html#ma...>
[0] https://applied-langua.ge/posts/lisp-curse-redemption-arc.ht...
There are no gatekeepers, no dependencies!
This, require you to have pay $20-$200 to a 3rd party corporation, or have a kind of beefy GPU (to run locally), run some instructions on text file, keep editing till it might does what you intend it to.
You are knowingly adding a dependency, which probably will become a hard dependency when everything goes jumbled up for human reviews, either on a beefy GPU or sending your data to a shareholder pleasing corporation.
Let's distinguish, how these are not the same, and the real price we pay
For CRUD apps, the API spec and UI mockups -- or even a photo of how it looks on the already coded platform -- would go a long way. That's exactly the kind of well defined task work LLMs do well with. It should be possible to automate a lot of the equivalence testing too.
Is there still an excuse for "maybe we'll add Android someday" or "not enough Mac/Linux users"? And is there still a justification for not building those less-used flows like password reset into the iOS app instead of throwing up random WebViews?
For those apps that do have non-trivial logic on device, LLMs have shown a lot of promise at rewriting to cross-compiling-is-easy languages like Go or Rust.
My original spicy take is: why learn SwiftUI at all at this point? It's a skill that, for most tasks, falls into the same kind of bucket as "learning Microsoft Word really, really well". I appreciate people who take the time to do that, but the outcomes are within millimeters of each other whether or not we do that.
I don't think that's true of programming generally. But I think there are languages now where the rationale in specializing in them has gotten, hrm, more complicated.
It looks off and it’s suboptimal performance-wise. It was, I’d say, 80% of a proper SwiftUI app (which is really fantastic given it was basically a one-shot).
Actually knowing SwiftUI meant it was trivial for me to just close out that remaining 20% by hand and have an actually *nice* cross platform (iOS, iPadOS, macOS) app.
I’m sure I could have prompted it to get it done right but without proper knowledge on the subject I wouldnt even know what was wrong and Claude doesn’t do so hot with “that just feels wrong”. Beyond that it was quicker to do it myself, but maybe I just need to prompt better /:
Over the years I've replaced 90% of the plugins I used when I started. Plus I get a nice outlet from any pesky NIH symptoms.
In all honesty, when you start up emacs for the first time with a blank config, it looks terrible. But then you start building it up with plugins and adding code to support your own quirky workflows and slowly it becomes too powerful in your life to ignore. I have not been able to drop it for 13 straight years. With AI taking over the development experience, emacs and neovim have only become even better, because now you can get AI to bake your custom workflows into the config for you.
Emacs/neovim should be the gold standard for all workflow tools.
I make small config changes every day and its super fun to use my computer this way. I wish everything was configurable like Emacs.
It is? Why? I read monospaced text all day long. I don't find it fatiguing in the least. In fact, I think I might prefer it to non-monospaced text.
edit: typo
I can see a table of contents being useful though. Perhaps if `:Toc` doesn’t exist yet, it should.
Most other "knowledge" professions -- by which I mean teaching, programming, some engineering, and the arts -- are even further along into obsolescence. That said, you can still use the knowledge gained in a knowledge profession to convert into a more hands-on profession. We might have a bit longer before humanoid robots destroy all hands-on job opportunities as well. Once that happens, every person will be equally poor and destitute.
"Content creation for an audience of one" is really the revolutionary change that is happening right now because of AI. Disposable apps, disposable books, disposable movies, disposable music. Things that are made for a single person, used once or a handful of times and then thrown away. The entire economic model of content creation and distribution is going to explode in the next 3 or 4 years, and very few people are prepared for it.
A- The difficulty to publish the tool
B- The difficulty to create the tool
C- The usefulness of the tool to others
D- The social reward for publishing the tool
E- The negative incentive of adding a dependency
Difficulty to find a canned solution goes up with A (because someone needs to create it) and B (someone needs to figure out how to publish it), but, the more useful it is to the community (C), the easier it gets to find it, because people will tell you.
If A and B are substantially different, if A is much higher than B, people will tend to write their own and forget about it. If B is lower, there will be fewer solutions to your problem. If A and B are low, and the social reward (C) for A is higher than the price of depending on something else (E), you'll have a leftpad situation. A lot of NPM is made of packages with high C and D and low E.
In the case of Emacs Lisp, A used to be high, but now is low, B (once you climb the learning curve) is low, C, D, and E aren't high either way. This can lead to a scenario where you build the tool before you even look if there is a tool that does it (unlike it is with VSCode, and with Eclipse before it - both have a high B).
I see a thesis someone younger than me will want to bring out to this world.
I'm using Emacs since last century and I've got 3 000+ lines of custom Elisp code I wrote (with maybe only a few hundred lines copy/pasta'ed from other configs).
I'm always using a recent Emacs compiled from source and now with LSP, org-mode, Magit, tree-sitter, ivy/avy/counsel/swiper with ripgrep (thanks burntsushi) integration etc.
I had zero frigging idea what gfm and gfm-view for Emacs were.
But I'll look into it now!
The reason people who like emacs write their one-off program in emacs is that it is an extraordinarily introspectable and debuggable programming environment. There is no "code, compile, run" loop - you just write code against the live running environment. Devoid of that fast feedback loop, writing code just isn't as much fun.
> they’re hamstrung by the terminal itself, which is almost always monospaced and thus fatiguing to read.
I recently re-built Blue, a minimalist text editor inspired by the Turbo Pascal and Turbo Basic editors of the late 1990's. It uses a fixed width font, because I prefer it.
I wanted to reference some TLA+ community stuff. I was initially just copy-pasting the specs into mine, and that worked well enough, but it was a little tedious and I was kind of afraid I might accidentally forget to give attribution to someone if I used their spec.
So I got Claude to build a TLA+ package manager for me. It's just a basic thing in Rust that allows me to plop a deps.json file into my TLA+ folder, and put a git repo url and commit hash, and then I use tree-sitter-tlaplus [1] to rename the modules to have a basic namespace to avoid collisions. It took about 30 minutes of fighting with Claude, but then it worked fine.
As AI gets better and better and cheaper and cheaper, I suspect it will be easy to have tons of custom apps for everything. It's a brave new world.
[1] https://github.com/tlaplus-community/tree-sitter-tlaplus
When my Emacs opens a markdown file it immediately converts it into OrgMode format. I find that more readable, more navigable and more editable.
Now I'll have to go and meditate about Emacsification.
Fun anecdote - I once needed to sort some nested items in a big yaml file. After spending three minutes trying to understand sort-regexp-fields (or some other function), I cheated - I ran org-mode, and then org-sort and then went back to yaml-mode. So stupid, yet so brilliant. Why the heck would I ever want to use "first-class IDE" or "intuitive, plebeian editor" if Emacs has anything I could possibly imagine? Right at my fingertips.
___
¹ https://github.com/agzam/org-edit-indirect.el
² https://github.com/thanhvg/emacs-hnreader/
³ https://github.com/thanhvg/emacs-reddigg
⁴ https://github.com/agzam/slacko.el
I want that. Can you give some details?
A search finds modeverv/markdown-to-org which looks 80% there but activates based on a yank or converting an already loaded markdown buffer. Perhaps it can be made to apply on opening a .md file.
Please do not do this.
Per OurWorldInData, >50% of the world lives below $10/day in 2026.
A $200/mth AI subscription costs ~66% of that.
Generation costs still exceed distribution costs by a wide margin.
Uploading costs you nothing, and it can help the poor.
Could you expound more on this? Are you suggesting that less energy use in data centers would help the world's poor?
Maybe it's best to call this movement in LLM-generated software "software individualism" rather than "personal software"?
[1] I don't know much as I haven't vibecoded before, and my .emacs is painfully crafted by hand.
Took me 2 days to complete, did not even spend the whole day on it (more like a bit here'n'there while doing other work. Claude's a game changer for these small greenfield projects (probably for more types of prjects, but this is a really sweet spot).
At work I have a great brain dump + TODO list tracker via custom API + MCP into confluence, using confluence pages as the app state. The website is so bloated it takes like 20 seconds to go from "idea" to getting it written down. Im now able to avoid all of that and make ~ MY ~ perfect UX while still being a good corporate employee.
But now it occurs to me: I know precisely how I work, I know what patterns are valuable to me, I know when and how I need to remind myself of things. I don't know why I haven't already started building my Things.app replacement. But I'd guess I have it to a place where I'm happy by this time Saturday.
Honestly, it's harder for me to think of daily-driver apps where this wouldn't be the case. I guess vector graphics editing? I'm not going to vibe up a vector editor. But I'll bet all the money in my pocket that 5 years from now, the real value in vector graphics tools will be their API/SDK, not the packaged application experience.
Podcasts: audiobookshelf
Music: 500 different subsonic clients, many of which are good. Or some fun tuis
Feed readers: lol, more than there are grains of sand in Torvalds' flippers
Note taking: again innumerable, also, just use nvim or emacs of course
Chat: tons of very good self hosted options that can save orgs thousands a month.
Rather than build your own from scratch, rediscovering already solved issues, why not contribute to or fork a FOSS project? LLMs make it easy easier to get up to speed on large projects
The point of the post is the emacsification of the native macOS (and Windows, I assume) environment. Totally reasonable not to care that it's occurring, that's not really responsive to the post, is it?
This is an experiment towards that:
https://github.com/dharmatech/9social
The first client is written for plan9. This keeps the design honest. (If it can run on plan9/rc/acme...)
Video demo:
The current implementation is less than 3000 lines of code.
And speaking of Emacs... 9social was heavily inspired by an Emacs project called Org Social:
Nice! This sounds just like what I'd been thinking the system should be like.
But how do you manage identity/authentication , or discovery of other users?
I've been thinking of this as well:
Something like old school Facebook in UI, but functions more like MSN Messenger. You connect to your contacts via P2P, and download/upload updates to your social media network.
https://repo.autonoma.ca/repo/timeivy
An unfinished spreadsheet-based interface for entering time. Meant for consulting, but never got around to persisting the data. Mostly created it because I couldn't stand all the ways that time trackers force users to enter structured time when there's a cute algorithm to handle just about every way a human might naturally enter time.
https://stackoverflow.com/a/49185071/59087
* Recipe managers
https://repo.autonoma.ca/repo/recipe-fiddle
In the days of LLMs, it would be far easier to categorize ingredients and format them into TeX for publishing as a PDF file. The idea behind this project was to let people essentially copy/paste recipes off the web or scans of handwritten content and autoformat it.
Email is right there waiting for disruption.
I'd say the thing with email that most improvements would need improved standards?
That said, as with the emacs user example, the ability to automatically process all your email in madly custom ways can now be opened to the masses.
It is very inspiring.
Yep, I'm doing this all the time. I've been doing it for a year. The silliest on is an IG post previewer. My app is better suited to me than the preview function that Instagram provide itself.
... actually, now that Servo was released to crates.io, I wonder how long it will take before `C-x w t` does exactly what I'm wishing for.
So LLMs are good enough to make personal software, but not good enough to maintain them?
I mean... yes?
Maintaining software means looking at issues opened on github, keeping your own list of feature requests and bug fixes, deciding if and what to fix, deciding when to fix, and if you're lucky/cursed, reviewing PRs from randos. ANY of this means diverting attention from your day job/client work/kids/???.
Can some of this be theoretically automated by an LLM? Uh, maybe? But I'm not sure how much that would help.
I don't want to spend time on dealing with change. Hence why I'd rather purchase tools, where I pay for the developer to a) prepare for any maintenance, and b) will perform the maintenance needed.
(Of course, the maintainability of software with current generation LLMs depends a lot on how well your architecture them. I've got pure vibe coded slop, that can be very difficult to wrangle.)
I honestly can't even relate to what that even means. I'm a programmer - my everyday job is all about changing the behavior of computer systems - local, remote, cloud, embedded, etc. Requirements change, scope fluctuates, problem space evolves - grows and shrinks, accretion is unavoidable. I need to routinely move between language stacks, different data types, formats, CLI and web tools, protocols, paradigms, OSS and proprietary apps.
That means I have to constantly adapt, my control plane has to keep up with the flux. Automation is key - you must develop a mentality for that - every little annoyance can be and shall be automated. That is an endless, non-stop transformation of my workflow - continuous maintenance of my tooling. But that is not some toilsome, reactive maintenance.
Thinking that you're a programmer that doesn't want to constantly build software for your own sake is a delusion - it's like a cook that hopes to turn on the stove only in the restaurant, but won't touch a knife at home.
Emacs is the cook's home kitchen. I'd say there are two kinds of maintenance: reactive (fixing breakage, keeping up with churn) versus generative (shaping tools to match your evolving understanding). Programmers instinctively dislike the first and should be drawn to the second. Emacs is almost uniquely suited to generative maintenance because the tool and the work share the same substrate.
I get your complaint about Emacs specifically, it's a common: "too much work to set up", which usually means: "I don't want to invest before I get value", which honestly is not wise, strategic thinking. Treating Emacs as the universal tool for minimizing total maintenance burden over a career, over a lifetime is.
Programming is also so much broader than something like cooking. It would be like saying that "you make your living manipulating matter, how could you not want to manipulate all that other matter?" to a chef. Their cooking doesn't necessarily make them want to mend clothes, remodel houses, devise new pharmaceuticals, etc.
That is, the idea that a non-expert might create interesting software in an authoring environment with good, well-thought-out building blocks and easy-to-grasp metaphors, shorn of layers of accidental or over-engineered complexity.
In this vision software still requires careful logical thinking, but it makes it much less cumbersome to translate that thinking into running code, with no tooling and build system nightmares.
Instead, we've invented such powerful models that they can regurgitate and recombine complex incantations on our behalf. The complexity is still there, though, and it's still inscrutable to non-experts.
But maybe they can help us eliminate some of it?
I think that path is still possible, and it may even nicely complement the LLM world, where LLMs help generate software that individual humans can still easily comprehend and manually modify.
I strive to make these kinds of tools.
To me, it isn't a matter of if, and the matter of when is also very clearly in "at most 10 years, probably much, much earlier", given that I have relatives already doing this without knowing how to code.
This is a future of computing I am absolutely in love with, and is so incredibly empowering!
Arguably LLMs take us further away from that than we've ever been. All they do is automate copying and pasting in shit from StackOverflow.
We were closer to everyone being able to learn how to program computers in the mid-80s when everyone had one and they started up with a BASIC prompt.
I feel I'm there. Whenever I have a problem I definitely ask "should I vibe code an app for that?"
My current Swift app has 15K LoC (5K in tests, 10K implementation) and it is finished. Like, there are minor improvements now, but it does what it needs to do. It took me 20 hours. I think the actual thing would personally take me 500 hours as I haven't programmed in Swift.
I'm excited that the weird grey-zone of excel sheets with business critical logic is likely going to disappear as LLMs slowly make the logic driving those too complex to be comprehended and managed and those get foisted off onto actual engineering resources. It'll be painful but probably for the best... but for actual tools people need to use day-to-day I think the assurance that the tool will work has a lot more value than the AI hype has comprehended.
Oddly enough, Google’s LLM is the only one that has been answering my questions well on a research project these last weeks. I’m getting information from scanned text files that exist on the internet but were never adequately OCRed by other LLM companies (i.e. both OCRed at all, and moreover OCRed as the specific language in question that picks up all the diacritics). Google search results may be disappointing and polluted for years, but the company is still offering a useful product in another tab of its interface.
We probably won't end there due to how lazy most of us are, but it's certainly something to consider
Everyone having their own hyperspecific apps or even different UIs/visualization in the same app
The whole idea of an application becomes a much more fluid thing
If your app is built with a dynamic language why not let users re-write the code themself and add whole new features
> The entire economic model of content creation and distribution is going to explode in the next 3 or 4 years
I think this is also inherently self-contradictory. What's the point of distributing content made for one? This gets into the same fallacy that people engage in w.r.t. "applications for one" displacing software developers. Yes, LLMs can pump out buggy software that suits one person's needs, and it doesn't need to be reliable enough to deploy at scale. It serves real utility here, because there was a gap between "the value of such software" and "what software developers are willing to work for", which meant that this software wasn't being created because there wasn't economic value in it. But then, how does one suppose software that has no economic value is going to replace all the professional software developers who were being paid to produce software that has economic value? LLMs filled a gap software developers weren't being paid to do, but given that they were not paid to do it, their jobs are not contingent on the existence of this niche. It simply doesn't follow that being able to produce content with zero economic value, whether that's applications or content for one, will cause an 'explosion' in the existing economic models.
Applications for one, might serve as a sort of "ultra-processed software" that can fill useful niches like generating textbooks on the fly (https://news.ycombinator.com/item?id=48130679), generating focus oriented music for long study sessions, and obviate writer's block.
However, I feel like there are downsides that are both obvious (insularity, discoverability, reliability, and platform dependance) and non-obvious issues which will take time for the public to determine what they are.
It's not "about" Emacs, it's more about the vibe of personalized software in 2026 to someone who does a lot of Emacs stuff.
Emacs-effect. Use it long enough and everything becomes "one big programmable surface". I've been in that modus operandi for years. Emacs is my "control room", I don't necessarily do everything in Emacs, but for sure it converges all into it - everything flows through Emacs. I control my WM directly from the REPL inside Emacs. I can grab a content from a tab in my browser - I have access to my browser history, and all the tabs, I can switch to any tab, close and re-order them. I can grab a text selection on the page, I can extract entire readable corpus of an article while ignoring all the irrelevant fluff - banners, ads, buttons, etc. It works even for js-rendered content (React, et al.). I play all videos controlling them directly from Emacs - even though the video itself is playing outside, in mpv. I still can pause, change volume, fast forward, speed-up, extract transcript, etc. All without leaving Emacs. That's pretty useful when taking notes. I can grab any text I see on the screen. Even if it's in Slack.app. Why, If I can read it, there's no reason why Emacs shouldn't be able to. I can grab any region on my screen with Flameshot, it goes through Emacs, runs tesseract and OCRs the text out of it. Useful when someone's screen sharing in Zoom. This was all possible before LLMs. Now, LLMs running in Emacs can do some crazy, wild stuff.
Another thing is configuration (which also ties to the previous statement). You have to be able to split the idea of the program (what it aims to do) and your personal preferences. Emacs make that easy by having a framework for user preferences. That makes for an extendable program.
The closest, but not as user friendly is unix and suckless philosophy combined. Small programs, easy to understand, configure, and extend.
Besides being an everything app for you, Emacs is an (unconventional) operating system with weak boundaries between user apps. It makes it easy to modify anything, write new things, or combine two existing ones with very little code, something that e.g. Microsoft could have only dreamed of in Office with its awkward embedding that barely worked. Emacs is one the few survivors of the idea that users should program what they need, which was popular during the personal computing revolution in the 80's. Two others are spreadsheets and BASIC.
Programming turned out to be too complex for the untrained users to handle, but AI makes the idea of custom one-off apps or weird hybrids pretty damn close, that is true in practice. I see a lot of people that vibe code their own little things to get things done. That's precisely what BASIC (often shipped in the stock ROM!) was supposed to be used for.
I think that "the number of programs" you're suggesting is arbitrary. It's kind of like calling an operating system one thing, when it's a lot of things. You can "count" the things different ways.
The bigger takeaway is "making your own programming things."
Feels to me like more than one message in this whole subthread talk about the Emacs culture.
If I'm shipping a product where each development/release cycle costs my team $5MM, I am absolutely going to spring for the professional SwiftUI developer.
But most things normal developers build in their spare time don't even cost $50 per cycle. Unless they're UI learning projects or projects by UI experts, there is no "budget" for UI. At best, for real labor-of-love projects, you get a TUI where the developer spends 5 hours of their life that they will never get back creating a 70%-functional terminal version of the affordances the native UI toolkit provides out of the box.
That's all over now. However competitive Claude-generated SwiftUI user interfaces are with expert SwiftUI projects, they roflstomp the UI options available to most developers. I can't say enough what a smoking gun the flickering Signal app is here!
Hehe. Definitely not to avoid the company micro time tracking their employees.
Audiobookshelf has a native android app, not sure about desktop, I only use it on Android.
Anyone can build a TUI sure but why try to rebuild the whole mpd client/server stack that lets anyone on your network play music from the several TB collection of FLACs on your NAS? Same for subsonic, why reinvent the client server protocol there when it's already solved? And for subsonic clients, why reimplement streaming, offline downloads with de-duping, stream bitrate, album / artist handling... If there's something a subsonic client doesn't have that you want, fork it, point claude at it, done! That probably falls within the emacsification thing, right?
Here's my personal profile on 9social:
https://github.com/dharmatech/9social-user-dharmatech
Each profile has a `following` file which shows who they're following:
https://github.com/dharmatech/9social-user-dharmatech/blob/m...
So, once you know someone on the network (now you know me!) you can see who they follow. And who each of them follow... And so on.
Well, each user's profile is just a git repository (possibly on github). So I'd think about identity/authentication in the same way users think about it for their code projects.
If you have specific scenarios you're wondering about, feel free to ask.
Cool! Thanks for checking it out!
"There's a filesystem for that."
¯ \ _ ( ツ ) _ / ¯
Google Search declined in quality when results started containing more noise (more ads, SEO spam) that required sifting through. Gemini isn't displaying all that garbage.. yet.
But it would allow for a culture to grow where the posters would self-contain their submissions into those threads.
Before the CLR was the JVM.
Before the JVM was the Smalltalk VM.
Before the Smalltalk VM was the Pascal P-Machine.
Before the Pascal P-Machine was the BCPL O-Code interpreter.
I think you missed flash. And arguably, to the author's point, JavaScript in browser (not wasm).
Yup, local-first is central to the design.
And, you only see who you explicitly follow.
I hope there's a sympy-thagoras out there.
( • ‿ • )
Their local-first approach inspired that aspect of the 9social design.
However, a big difference is that SSB is a sophisticated protocol.
With 9social, the heavy lifting is done by git and a set of conventions.
Thanks for checking it out!
For example, we can "reclaim" non-DRM ebook readers, audiobooks, and music players that play local files or use an open API. But a company-specific walled garden streaming DRM'd ecosystem will be almost impossible to build around.
I gotta be careful, I'm going to talk myself into staying up late tonight building that.
Ownership can have different forms. Slack.app that doesn't let me easily extract code snippets from a thread - owns me. Jira that forces me to use their imbecilic, quirky wysiwyg owns me. Note taking app that keeps the data in their db and not my files - ain't my friend. The friction is the ownership. When extraction requires effort, the tool has leverage over you. It's a subtler form than data lock-in - behavioral lock-in. You adapt your workflow to what the tool makes easy, and gradually the tool's affordances shape what you even think to do. information gets buried in threads, search is mediocre, export is hostile. The "solution" they offer is to stay in Slack/Jira/Dropbox/Evernote/Notion/etc. longer, search in Slack, link to Slack, screenshare in Slack, summarize with AI in Slack, don't ever leave Slack. The tool becomes the answer to the problems the tool creates.
Plain text, local files, standard formats - they don't fight you on extraction because there's nothing to protect. That's why investing in FOSS tools is almost always paying for your own liberation rather than your own imprisonment. Even when there isn't feature parity, even when the FOSS tool doesn't have a "polished UI" and it's "maintained by a teenager in Nebraska" - still a better choice.
I don't know what the other parts are. Curious to learn!
Of course I can't explain in detail in a single comment everything I listed, besides, that's just a subset of things I do through Emacs.
Sometimes I want to kick off a process in the external terminal - long-lived processes are better handled that way. Kitty has remote protocol. I needed bidirectionally - being able to pipe into and from an arbitrary Emacs buffer to and from the terminal, so I wrote the Piper¹. This kind of stuff should be built into Emacs, maybe someone gets bored and sends patches, if I get to it, perhaps I'd myself do it one day.
I gravitate towards CLIs and tools with built-in IPC layers, Emacs is terrific with inter-process communication. That's how I manage my WM on Mac, where I use Hammerspoon. Wondrous piece on its own, it is Lua-enabled, which means I can use Fennel, which means I can have Lispy-REPL, which means I can connect to it directly from Emacs and manipulate all my windows among a bunch of other things.
In Linux, I have build a similar modal toolkit² (experimental) that is written in Babashka (Clojure), that means I can expose nrepl port and use it with the Lispy-REPL. If you don't know what's such a big deal about it being a Lisp REPL, here's my comment from the other day³.
MPV is amazingly hackable and has an IPC, you can nearly fully control it without touching it. I have built some customizations on top on mpv.el.
To access the browser, I use OSA (open scripting architecture) with some JXA snippets. Unfortunately, there's nothing similar for Linux - the only thing one can do is to run the browser with the RDP port exposed. Although, you still can access the browser history - every major browser keeps it in a sqlite db⁴.
OCRing any text is a straightforward piece of Elisp⁵ - it just checks if there's a graphic content in the clipboard and if it is - it saves it into a temp file and feeds it to tesseract cli. It's not as accurate as most modern OCRs, but it beats everything else in speed. For my purpose (typically grabbing a piece of Zoom screen share) - it works.
Hope this helps.
___
² https://github.com/agzam/tecla
³ https://news.ycombinator.com/item?id=48113368
⁴ https://github.com/agzam/browser-hist.el
⁵ https://github.com/agzam/.doom.d/blob/main/modules/custom/wr...
(I admit it's added up to more than zero though! Keeping (require 'cmake-mode) working reliably on Windows and macOS has proven a minor annoyance, and fonts seem to require a degree of system-specific attention.)
I just disagree with why Emacs heavy users are often "blamed" to be obsessed with their tools "needlessly". What does it even mean to desire "as little maintenance as possible"? Okay, let's say I don't use Emacs (which is like I dunno over 90% of existing programmers in the world). What, I won't be writing bash scripts for my work? Okay, maybe I really hate Bash. Python then? Lua? Perl? What the hell are we even talking about? Of course, a programmer will do these things. Every programmer does. There's not a single case where a programmer doesn't tweak, re-tweak, personalize, improve, readjust their tooling, their scripts, browser extensions, the set of apps they use. Why is it Emacs and Vim considered a "perpetual maintenance", and I dunno, VSCode is "it just works™"? That's just not true. If I didn't use Emacs, I'd be inevitably re-inventing some workflow automation in some different way. Or what, bash-scripts ain't no software?
1. Yes, everything has a maintenance cost. Some choices have less. For instance, electing to choose Todoist instead of org-mode for my todo list means I no longer have to worry about syncing, merge conflicts, or whether the mobile app I've chosen fully conforms to the spec (well, whatever attempt at creating a spec existed at the time).
Of course, I am paying a very literal cost for convenience, and offloading maintenance to the Todoist engineers.
2. Emacs is a cool piece of software, and I am glad others have figured out how to leverage it, in such a way they have a configuration for life. I spent a lot of time marvelling over the set up that Protesilaos had for his writing [0]. It just wasn't for me.
3. For Emacs, if I want to use it like I wanted to, I have a couple of options. Install a package like Doom Emacs, which gives me most of what I want, with a whole lot of cruft I don't. And I have to keep that up-to-date, and worry about random community plugins breaking. Or figure out what set of plugins (after first picking a package manager) to incorporate. Or figure out the Elisp to do it myself. And my writing config would differ from my software engineering config.
No shade on the people who want to do this, but I just... don't? I can use Zed, or VSCode, and I'm 90% of the way there. Install (or configure) the Evil mode equivalent, and I'm happy.
4. One of the smartest engineers I worked with couldn't touch type until about 20 years into his career. The idea that everyone is ricing everything they do, is unrealistic.
[0]: https://protesilaos.com (purely for the emacs, not anything else there)
Literally everyone had a ZX Spectrum, or Commodore 64, or a BBC Micro if their parents were rich and thought that having the same as they had at school was a good idea.
They were cheap and ubiquitous, unless I suppose you were in one of "Iron Curtain" countries.
And I would love it if more services had an Open API and allowed people to write their own clients. I like the concept of "emacsification of software".
But I find it a little extreme to say "it's faster to build your own than to install an existing alternative". You still have to spend a lot of time building your own, it's just that now it's realistic without taking a sabbatical.
For my part, I am not only a nerd, I am literally an Emacs-using nerd, and I am not interested in using LLMs to create a plethora of bespoke applications that are subtle tweaks on existing tools. I haven't ruled out using AI to assist in helping me with a program that I've been wanting to write for years, but a lot of what's blocking me on that is figuring out design aspects that an LLM wouldn't be able to help me with in the first place. (I'm also concerned about "vibe-coding" programs that I don't 100% understand, at least if they're programs that I might ever want to release into the world.)
I've ran into this problem many times. I'm quite pleased that the AI can complete the 'last mile' on many of my old projects. I'm finally publishing my packages! Time will tell if they're any good but at least they're buildable, testable, lint-free, documented and installable now.
Installing an existing alternative might be easy ... once you found the one which best (i.e. mostly) matches your requirements. The time consuming task IMO is the time needed to find and then choose between half a dozen (or so) alternatives which all might do the job ... until you installed them, tested them, and found that they are insufficient for the job you expect them to do.
Even if the coding process itself is “effortless” and the agent just churns away to implement whatever I ask for on a dime, it can become exhausting thinking through all my needs/wants, tradeoffs, API shape etc. Despite not needing to write a line of code myself or read more than excerpts in the chat it can turn into a slog after the honeymoon period passes and it starts to feel like unpaid work.
I’ve had moments where I’m relieved to discover a popular open source tool that works out-of-the-box as an alternative to my own so I can offload that organizational overhead and decision fatigue to someone else. While benefiting from all their features/enhancements I didn’t have to design or maintain myself over time.
As an example, I had been building a TUI/web app to download and organize ebooks from various sources like Project Gutenberg or Anna’s Archive with a central meta search, and manage my personal library. It solved the immediate problem at the time but I kept needing to add missing features, plug holes in the various search integrations, UI refinements, etc and it never quite worked exactly as I wanted so kept having to work on it and became less and less fun as time went on.
Then I discovered Calibre Web Automated + Shelfmark on GitHub that did 99% of what I needed plus a lot more and overall had a level of polish and reliability my tool never reached. Now I just pull a Docker container every so often for updates and made a few tweaks to syncing but overall spend vastly more time on actually reading/organizing/growing my library vs. increasingly tedious vibe coding sessions and it feels so much more enjoyable.
I still have plenty of self-designed tools and continue making new ones but now tend to reach for an existing, off-the-shelf option first whenever possible for anything more complex than a one-off script. That way I can benefit from a community collectively contributing to improve and maintain the project over time without needing to become an unpaid Product Manager, Lead Designer, Senior Developer and QA Manager for everything I use.
I hope the current period of exuberance around LLM development doesn’t lead to everyone becoming stuck in individual silos duplicating work that in the past could have been directed to an OSS project where that time investment could be shared with everyone else and benefit from way more eyes catching bugs and smoothing off rough edges.
> could have been directed to an OSS project
My feeling is that it is not exactly a risk. People who are keen on contributing to open source will do it even with AI, and people who are not wouldn't do it anyway.
> Thinking that you're a programmer that doesn't want to constantly build software for your own sake is a delusion - it's like a cook that hopes to turn on the stove only in the restaurant, but won't touch a knife at home.
> Emacs is the cook's home kitchen.
The two sentences are adjacent. I read them as connected. If you meant them to be unrelated, I hope that this sheds light on our disagreement.
What I meant is that viewing Emacs merely as a means to achieve a singular goal and to extract specific value (e.g. "I've heard Magit is nice") is shortsighted - approaching it as a strategic, long-term investment yields far greater returns. I'm not preaching for absolutely every programmer to use it.
Come on, now tell me how I think of everyone who doesn't approve my web-browser tweaking habits as "catastrophic failures"...
I suppose it's a bit like television, it would have been more popular where it was invented.
People are not a monolith and, for example, you have zero fucking clue about my motivations.
You do you.
Did you live in the UK in the 1980s?
Yes.
> One specific model of ZX Spectrum
I do not believe this to be the case, that number appears to include the 128K and the Amstrad variants also.
Programmers write programs. That's the definition of the job. Any personal tweaks - scripts, snippets, extensions, packages, configs (for VSCode, IntelliJ, Vim and yes Emacs too) are also programs. Saying: "I don't want to maintain my programs" sounds to me like saying: "I don't want to be a programmer". It doesn't matter what I use - Emacs, Sublime or Macromedia Dreamweaver - configuring and maintaining it is not "kind of a job", "part of my job", or "someone else's job". That is my job as a programmer. Period. End of discussion.
Why the fuck you keep pouring your own made up shit from one pitcher into another, thinking it's about to turn into gold, is beyond me. And somehow I'm the dude that should "relax". Well, sure, let me then apologize for my inability to explain to you something that a six year old would get off the bat.
I don't owe you an explanation why I do it, why write anything at all. Why HN. I'll say it anyway. I do it because I still recognize people here. Living, dreaming, learning, fighting, hating, daring, loving people. I don't get paid for it, I don't seek recognition, I am not trying to build a name. I share my opinions because nothing is more important for our species than storytelling. And we need to share stories, listen to them, re-live them, learn from them. That's why many of us would go to watch Nolan's rendition of a 2700-year-old story. Even if we don't like the movie already.
And then someone like you comes, shits all over your charming writing, compelled to do it just because they see a word they don't like. Well, honestly, fuck you. Yeah, not nice, but I'd rather be kind and tell you the truth. You wouldn't be saying the shit you replied to me with to my face. Not because I have muscles, or am intimidating, or weak and miserable, no. But because you're definitely not a jerk, or an idiot. I wouldn't have to spend hours wasting on your ass for no good fucking reason. Seriously, I am a solo father with two kids, it's fucking 1:30AM and I'm having to deal with this shit, because writing for me is still fucking hard. English is beautiful, but hard. Come on, kid, think sometimes. For the sake of fellow humans.
How old are your kids? I ask because unless they're teens or older they need a well-rested dad.
I do truly appreciate your concern though, thank you for your support. Often, a single sentence with a human touch can remind you how much of our shared humanity we've buried under the noise we've convinced ourselves matters.