One of the arguments for open source software for end-users has always been the freedom to examine and modify how that software works.

The reality for most people - even expert programmers - has been that the freedom is more about being able to lean on other people to do that. Most people can't justify the time commitment needed to read and then modify the code for tools they use very often.

I think LLMs have changed that equation in a way that makes the original dream much more feasible.

Several times a day I'll prompt regular Claude chat to "Clone x/y from GitHub and tell me how Z works".

Getting software to compile in order to start hacking on it used to be enough friction that I often wouldn't bother. Now I treat that as a zero time investment challenge: tell Codex or Claude Code to checkout and build X and then come back ten minutes later and see how it got on.

I'm not habitually modifying the software I use yet, but I can see a path to that which didn't exist a year or so ago.

I agree that devtools should be open source, but... I very much disagree with the premise that no tools should have config files, options, or plugin systems, and instead when you want to change something like your text editor's font size, you should have an LLM download the code, change the hard-coded value, and rebuild it.

That's just so inefficient and wasteful. Assuming a world in which LLMs do most of the coding work, do we want to burn electricity having the LLM build an options dialog or config file parser once, or do we want to burn electricity millions of times as users want to change any little thing about the software they use?

I really hope what you should expect is my answer to that question isn't controversial.

Having an LLM do bespoke customizations that are unlikely to be interesting to other people? Great, sure. But adding a generally-useful feature to a piece of software, but not caring to try to upstream it? Lame. Lame, lame, lame.

> Set up a nightly cron job that executes the prompt: fetch upstream changes to the <software> and rebase all local changes on top of upstream. Check that the software works as intended and replace the current version.

This sounds like hell. You have unreliable actor redoing the software every night, and every day there is a chance you wake up and find your workflow broken.

And no, "Check that the software works as intended" is not going to cut it, as AI are very, very good at obeying the letter but not the spirit of the ask. Yes, your diffs appear but they lack filenames. You've added this requirements to the prompt? Ok, filenames are back but they are font size 4, unreadably small. You want them well-seen? next week they become size 54, taking entire screen.. This is not a problem with regular AI development - you review the changes and test them a bit. But doing it day-to-day with no overview is just asking for trouble.

As a maintainer of a devtool which has strived to make itself easily forkable and modifiable, I can see the allure of this line of thinking but I think it's sadly too idealistic.

Engineers using devtools are not so different to an average user in that they just want things to work. Maintaining a devtool is real work; e.g. suppose upstream adds some feature you want but it clashes with something you did downstream. Not in the merge conflict sense but in the UX sense. Do you want to resolve that on every release? Is it just "AI will fix this"? Maybe one day, but as of today agents can do something along the right lines but don't capture my UX sense very well; and if the whole point is hyper-personalization, I want it exactly how I want it.

"Does it seem to work?" is a fine right until it fails when you're doing something important. Do you then stop and go prompt an agent to fix your tooling, and hope it does a good job this time? What if it doesn't do a good job?

Moreover, for devtools which are fundamentally social (i.e. lots of different people looking at the same thing), there's real value in that thing looking the same for everyone. Having a baseline for teaching, auditing, verifying "we are all talking about the same thing" is incredibly valuable and is sometimes where the most value is.

All in all, maybe in some categories of devtools, this hyper personalization is indeed what will happen but it's a long way from being universal.

I used to be much more of an open source fundamentalist than I am now. For me, it's more about trust than source availability. There are closed source projects that I have high trust in, and there are open source projects that I don't trust at all. A project being open source can increase trust, but not necessarily so.

Regarding personalization, I would much rather use software with strong design principles that's simple, opinionated, and works out of the box with sane defaults. I want to spend my time getting work done, not tweaking settings and adding custom features.

>How to Personalize Software

I've seen https://v-it.org/ here on hackernews. Same idea, different wording.

I've worked at a DevTools company and been the CEO of one too. Here's my thoughts:

I agree that they need to be open source. But that makes it really hard to make a successful business. Sure, there are examples of success, but also many examples of successful open source tools never becoming successful companies.

The most famous example is Sendmail (where I worked way back in the day). They took millions in funding and ultimately sold to an infra company, returning pennies on the dollar to their investors.

The difficulty stems from the fact that your customers are developers and operators, and they all think that they don't need you because they are perfectly capable of running the software themselves and adding whatever they need to it. In a lot of cases they are right.

And now, with AI coders, it gets 10 times worse, because they can take your open source and then vibe code a "good enough" version of your commercial product.

I don't know how to square this circle. There are a lot of great dev tools made by people for free for the love of the game. But even those people need to eat.

Some tools have started making licenses that are free for individuals and startups but cost money for profitable companies. That's an interesting strategy but I know some companies won't allow those tools precisely because of their license.

Some time ago, there was a comment https://news.ycombinator.com/item?id=48849015

I deeply disagree with the light vs dark framing. I think the real tension between "hacker languages" and "blub languages" is the expectation to modify the language by it's user.

And this is true for dev tools as well. Hackers prefer modifiable environments (such as Emacs), while corporations prefer standard environments (IDEs) to which programmers will adapt.

(As the saying goes: "The reasonable man adapts himself to the world: the unreasonable one persists in trying to adapt the world to himself. Therefore all progress depends on the unreasonable man." Might be why Paul Graham preferred founders with non-blub languages after all, nothing to do with Lisp as such.)

But to be able to adapt the environment, one must understand it. Therefore the pull to make it simpler, a set of universal tools, rather than a complicated machine with many features and ease of use through following prescription.

Separately, JetBrains's revenue grew 25%: https://www.jetbrains.com/lp/annualreport-2026/

But back to OP, for this prompt:

> Set up a nightly cron job that executes the prompt: fetch upstream changes to the <software> and rebase all local changes on top of upstream. Check that the software works as intended and replace the current version.

Seems like nice syntax sugar to add a `/maintain-fork` command.

I'm not against open source. However, if I were to guess, I think less than 1% of people actually review, let alone modify the open source projects they use. I don't really buy this argument.

I think we're seeing a new modality of openness now with open weights, or being able to modify agents with md files, skills, and so forth.

I disagree. As if a tool is customized via agents and something goes wrong, it should be the users issue to fix it. Say I want to customize a bank app (or sca tool) to use a nickname instead of my name, if it breaks then who fixes it?

"Five years ago, most software engineers I spoke to had no programs they had written for themselves."

What happened five years ago? Before that everyone used tools they wrote themselves. I think the answer is nothing happened five years ago and everyone still uses tools they wrote themselves.

A bit idealistic for the crowd here but has some good points.

The other day I wanted to build personal apps for my Kobo device. It has a single ~800Mhz core and 512 MB of RAM, probably eight times less than a rasbperry pi, but runs a Linux.

I wanted to break free from watching my laptop screen for long Claude sessions partially due to degrading eyesight and have a sidekick for approvals streamed to the Kobo. Apart from the Claude and Codex permissions sidekick done via hooks, I ended up building an entire SDK, an HN client, an RSS discovery & reader and an audiobook generator using deep research and ElevenLabs API all running on it.

Anyone using an LLM can now personalize it for their own Kobo device, which might have some nuances over my Clara BW. Significantly less work I hope than doing it all from scratch even with a coding agent.

https://github.com/BandarLabs/Cobalt

exe dev is a VC-funded company reselling open source software.

Everyone's making cash from your open source code except you.

Like everything else, modifying code of open-source tools has its cons and pros. The biggest advantage is of course an ability to customize the tool exactly to your needs. The problem is that it makes patching and upgrading impossible. This is the reason plugins exist - they do not break ability to patch the host product. So, if customization cannot be avoided even at the cost of losing ability to patch/upgrade - that would definitely work. Otherwise, plugins is probably the best approach.

I think this became aparent with agentic coding CLIs. In my company, it was not encouraged to use claude code because they haven't open sourced it yet

In the spirit of open source devtools & personalized software, check out my digital garden / monorepo I've been working on for 5years! For self-hosting NextJS on k8s & related infra like cnpg.

https://peat.eth.demokluster.com https://peat.eth.limo https://peat.eth.link

git clone https://peat.eth.demokluster.com/peat0.git

(webpage itself incl ro-git is hosted/mirrored over IPFS/ENS)

I think there is an argument to be made for how this benefits projects too, like if you want distribution then be as unencumbered as possible.

I've been making a couple little utils like a Clock for AI with an open public endpoint [https://github.com/firasd/mcpclock], a text file sampler [https://github.com/firasd/vblinds] and I was noticing the MIT license seems too encumbered with the requirement to keep crediting authors downstream so I used the 'Unlicense' public domain license

(CC-0 seems to be side-eyed by open source orgs cause it preserves patent rights)

LLMs make things easier but can we not advocate for making them a dependency to configure our tools?

Even open weight models aren't fully open source. It's basically like having the back end binary but not the source code.

Use em to make your life easier but I'd rather not we normalize LLMs becoming the primary way we interact with open source software.

I like using exe but I’m not sure what to feel about this if exe itself isnt open source. Granted, their agent is OSS, but still feels somewhat ironic

Everything is now open-source by default. All features are replicable. I don’t really care that much any more that tools need to be OSS because I can make my copies when I want. And I do when I so desire.

Your feature page is your source code.

Well we can go a step further and say Devtools must not be VC funded too :) Till date, the best and greatest dev tools I've used have not been influenced by VC decisions.

Good point, but extensibility != OSS though.

JetBrains and Claude/ChatGPT are not open source.

I think we would like them to be ... but ...

I like the idea but I think manually editing source code is a bit too extreme. I’d rather have a plugin system or make the config scriptable.

Open-sourced doesnt have to be free either. There's always the very good GNU Affero General Public License 3 (AGPL-3) and others. I think most developers want open-source for transparency. We want to know what we are downloading.

Devtools for open source must be open source, but I see no reason to give any shits what corporations use.

And we live in capitalism, where making money is not optional.

The models are dev tools ;)

So, I'm a subscriber/user of exe.dev but even so I was a bit disappointed when the meat.dev tool linked in the article had no screenshots/meaningful docs. So I installed it and was bummed to see it only supported openAI and exe.dev llm integration by default. "You can just fork" - yeah I know, so take it with a grain of salt.

That aside aside, I agree. Since reading this article yesterday I've probably been overthinking an MIT from AGPL license switch for my own project Ouijit (shill time: https://ouijit.com). Its feels a little counterintuitive since AGPL encourages more open source downstream, but at the same time if I have solved some problem other agent harness devs are curious about, I just want them to take the solution without worrying about paying it back/forward.

exe.dev is NOT open source. Funny

> The result is that software that can be personalized doesn’t need a plugin system or a config file.

Yes, please make me rebuild my software to change an API endpoint or port number. It's a wonderful use of time and electricity to build and spin up agents to fix the inevitable problems with building software. Instead of changing a string in configuration file.

(/s if not obvious).

Configuration and plugin systems exist for a good reason: software should be reconfigurable and modular without requiring the wholesale replacement of the original. Even if the code is open source, there are good reasons to move logic and data out of tree and into config or plugins.

Si

I like the idea of devtools being open source. I also like them to work, and that's what I value more that philosophical purity.

Take his side project, Meat. I've been chewing on this problem for a while. It's a real problem right now: it sucks to read all this LLM-generated code. It's worthwhile to have an LLM summarize it for you.

The problem with that is this particular problem resists vibe coding. I've talked to a bunch of people who have tried to solve it on the side, and it's all sort of ... ok, but still unsolved.

- As mentioned, it takes a while to run. You can modify your other tools, as described, to smuggle the latency.

- LLMs don't know what you care about, so you have to maintain a list of things that you do care about, which is ever evolving. If you don't give it that, it produces slop.

- If you miss something, it hurts. Another layer of swiss-cheese AI doesn't feel right. If you trust the AI, just ask Claude to summarize its work!

- The summaries feel shareable, but the author of the PR is actually the most tolerate of slop about a PR. Your reviewers definitely don't want to read the output of a vibe-coded tool talking about 60% of your PR. They could ask their own Claude!

So, we're building a version (https://tern.sh), and it's not open source, because we want it to be shareable and hosted and support teams -- all that stuff that makes it work. At the end of the day, I'm not here to maintain my tools. I'm here to use my tools to do the job.

It's a bit ironic to talk about key parts of the toolchain being open source while making black-box, closed source LLM's, controlled by external companies an integral part of all of it.

This is one of the only fields where the customer (developers) almost never pays for their own tools and instead builds their own or even to compete against another developer. Then, they later realize why human developers in open source burnout so easily.

Not even Richard Stallman or Linus Torvalds make money on open source or free software despite preaching it. They actually make money from speaking fees.

"Open source" is now weaponized to price down entire companies to the floor and instead of humans maintaining the software, it is now coding agents doing the work.

Neither the free and open source software movement accounted for this disruption and they have become the new starving artists of the software world.

Really? Software engineer and you just started making personalized tools recently?

Emacs has been customizable probably longer than I've been alive. Apart from tinkering with Basic, Delphi and Visual C++ when I was a kid, the first things I made were Ruby scripts as personal tools for various things. Had a personalized Emacs environment 20 years ago. Iterated on some abandoned open source projects. And so on...

I guess congrats on an AI telling you about things that have pretty much always existed.

Company that resells openclaw and closed providers preaches about open source.

The new personalization talking point appears to be coordinated. It is all over the Internet since last week.

Problem is, 99.99% of people (including developers) do not need "personalized" software, unless you mean Emacs style.