Small bespoke personalized on the spot apps are the future with LLMs.

The future will absolutely not be "How things are today + LLMs"

The paradigm now for software is "build a tool shed/garage/barn/warehouse full of as much capability for as many uses possible" but when LLMs can build you a custom(!) hammer or saw in a few minutes, why go to the shed?

I think you're missing the enormous value in apps being standardized and opinionated. Standardized means that in addition to documentation, the whole internet is available to help you. Opinionated means as a user of an app in a new domain, you don't have to make a million decisions about how something should work to just get started.

Sure, there will be more personalized apps for those who have a lot of expertise in a domain and gain value from building something that supports their specific workflow. For the vast majority of the population, and the vast majority of use cases, this will not happen. I'm not about to give up the decades of experience I've gained with my tools for something I vibe coded in a weekend.

> when LLMs can build you an custom(!) hammer or saw in a few minutes, why go to the shed?

Because software developers typically understand how to implement a solution to problem better than the client. If they don't have enough details to implement a solution, they will ask the client for details. If the developer decides to use an LLM to implement a solution, they have the ability to assess the end product.

The problem is software developers cost money. A developer using an LLM may reduce the cost of development, but it is doubtful that the reduction in cost will be sufficient to justify personalized applications in many cases. Most of the cases where it would justify the cost would likely be in domains where custom software is in common use anyhow.

Sure, you will see a few people using LLMs to develop personalized software for themselves. Yet these will be people who understand how to specify the problem they are trying to solve clearly, will have the patience to handle the quirks and bugs in the software they create, and may even enjoy the process. You may even have a few small and medium sized businesses hiring developers who use LLMs to create custom software. But I don't think you're going to see the wholesale adoption of personalized software.

And that only considers the ability of people to specify the problem they are trying to solve. There are other considerations, such as interoperability. We live in a networked world after all, and interoperability was important even before everything was networked.

> The paradigm now for software is "build a tool shed/garage/barn/warehouse full of as much capability for as many uses possible" but when LLMs can build you an custom(!) hammer or saw in a few minutes, why go to the shed?

1) Your specific analogy is kinda missing something important: I don't want my tools working differently every time I use them, also it's work to use LLMs. A hammer is kind of a too-simple example, but going with it anyway: when I need a hammer, I don't want my "LLM" generating a plastic one, then having to iterate for 30 minutes to get it right. It takes me far less than 30 minutes to go to my shed. A better example is would be a UI, even if it was perfect, do you want all the buttons and menus to be different every time you use the tool? Because you generate a new one each time instead of "going to the shed"?

2) Then there's the question, can an LLM actually build, or does it just regurgitate? A hammer is an extremely we'll understood tool, that's been refined over centuries, so I think an LLM could do a pretty good job with one. There are lots of examples, but that also means the designs the LLM is referencing are probably better than the LLM's output. And then for things not like that, more unique, can the LLM even do it at all or with a reasonable amount of effort?

I think there's a modern phenomenon where making things "easier" actually results in worse outcomes, a degraded typical state vs. the previous status quo, because it turns what was once a necessity into a question of personal discipline. And it turns out when you remove necessity, a lot of people have a real hard time doing the best thing on discipline alone. LLMs might just enable more of those degenerate outcomes: everyone's using "custom" LLM generated tools all the time, but they all actually suck and are worse than if we just put that effort into designing the tools manually.

"why go to the shed"

A good question but there's a good answer: Debugged and tested code.

And by that, I mean the FULL spectrum of debugging and testing. Not just unit tests, not even just integration tests, but, is there a user that found this useful? At all? How many users? How many use cases? How hard has it been subjected to the blows of the real world?

As AI makes some of the other issues less important, the ones that remain become more important. It is completely impossible to ask an LLM to produce a code base that has been used by millions of people for five years. Such things will still have value.

The idea that the near-future is an AI powered wonderland of everyone getting custom bespoke code that does exactly what they want and everything is peachy is overlooking this problem. Even a (weakly) superhuman AI can't necessarily anticipate what the real world may do to a code base. Even if I can get an AI to make a bespoke photo editor, someone else's AI photo editor that has seen millions of person-years of usage is going to have advantages over my custom one that was just born.

Of course not all code is like this. There is a lot of low-consequence, one-off code, with all the properties we're familiar with on that front, like, there are no security issues because only I will run this, bugs are of no consequence because it's only ever going to be run across this exact data set that never exposes them (e.g., the vast, vast array of bash scripts that will technically do something wrong with spaces in filenames but ran just fine because there weren't any). LLMs are great for that and unquestionably will get better.

However there will still be great value in software that has been tested from top to bottom, for suitability, for solving the problem, not just raw basic unit tests but for surviving contact with the real world for millions/billions/trillions of hours. In fact the value of this may even go up in a world suddenly oversupplied with the little stuff. You can get a custom hammer but you can't get a custom hammer that has been tested in the fire of extensive real-world use, by definition.

The vast majority of users make zero changes to the default settings of an app or device, even for software they use all the time and where some simple builtin adjustments would significantly improve their experience.

I simply can't imagine a world where these same people all decide they constantly want to learn a completely unique UX for whatever piece of software they want to use.

Because whatever you use a LLM to build will inevitably need more features added or some kind of maintenance performed. And now you're spending $200+/mo on LLM subscriptions that give you a half-assed implementation that will eventually collapse under its own weight, vs just buying a solution that actually works and you don't have to worry about it.

I do not think that this is likely to be a successful model.

When (not if) software breaks in production, you need to be able to debug it effectively. Knowing that external libraries do their base job is really helpful in reducing the search space and in reducing the blast radius of patches.

Note that this is not AI-specific. More generally, in-house implementations of software that is not your core business brings costs that are not limited to that of writing said implementation.

The more I experiment with quickly coding up little projects with LLMs the more I am convinced of this. There is that saying: 90% of your customers use 10% of your software's features, but they each use a different 10%. Well, the ability to quickly vibe up a small bespoke app that does that 10% AND NOTHING ELSE is here now, and it kind of solves that problem. We don't need to put up with DoEverythingBloatWare (even open source DoEverything) when you can just have the bits and pieces you actually want/need.

Also, you don't have to fear breaking updates--you know for sure that the software's UI will not just change out from under you because some designer had to pad their portfolio. Or that you're not going to lose a critical feature because the developer decided to refactor and leave it out.

I'm currently going through and looking at some of the bigger, bloated, crashing slow-moving software I use and working on replacements.

> when LLMs can build you an custom(!) hammer or saw in a few minutes, why go to the shed?

Because I thought I needed a hammer for nails (employee payroll) but then I realized I also need it to screw (sales), soldering (inventory management) and cleanup (taxes).

Oh and don't forget that next month the density of iron can lower up to 50%.

The 3d-printer of software: get a custom part quickly and cheaply, even if not suitable for mass production.

You could already pay Indians to make you software if you wanted poorly made software. Poorly making it with AI isn’t that big an improvement.

You go to the shed because you know the hammer has undergone extensive testing and won’t immediately be hacked, costing you hundreds of millions.

Why use a battle tested, secure, library that you know solves your problem when you can burden your project with custom code you need to maintain?

Hehe, you created quite the dog pile. Here's my woof:

IMO you only need to look at the 30+ year history of Linux to see how wrong this prediction is. There will be a small group of people who do as you say, but the other 95% will happily pay for someone else to take care of their problem. Convenience is the supreme king of the American market.

I can speak to this directly: I've customized a few extensions I use with VSCode, (nearly) completely having the AI generate/iterate over my feature request until it works. I don't have the time to learn the details (or different languages) of the various projects, but I get huge benefit from the improvements.

- PRO Deployer

- MS Typescript

- Typescript-Go

- a bespoke internal extension to automate a lot of housekeeping when developing against tickets (git checks, branch creation, stash when switching, automatically connecting and updating ticket system)

Because I will probably ask the AI for a rock instead of a bespoke hammer. If I even know what a nail is.

I very much like to use the years of debugging and innovation others spent on that very same problem that I'm having.

StanLLM-generated hammer: "Dear valued customer, our automated systems have flagged activity on your StanLLM account that appears to be non-compliant with our Acceptable Use Policy. As a precautionary measure your account has been suspended. If you believe this suspension is in error, feel free to contact our customer support at /dev/null^H^H^H^H^H^H^H^H^Hsupport@..."

Bespoke personalized apps have been around forever in the form of shell scripts. LLMs will expand that capability to a lot more people but won’t change the basic dynamics. Just like shell scripts, LLMs will need lower level building blocks to work with. The main difference will be that the LLM ecosystem will include some libraries as well. Though, I believe, most of those libraries haven’t been written yet.

This assumes an educated, passionate and patient user that 99% of people are not. They wont ask for a hammer - they will ask for a rock tied to a stick and get pissed off when it doesn't work like a hammer. They will ask for paint that doesn't drip. They will ask for electrical sockets they can install in their bathtub.

Maybe true for some apps, but I suspect we will still have a vibrant ecosystem of package managers and open source libraries and coding agents will know how to use them.

Would you trust your hand next to a saw made by an LLM?

My personal theory is that as the excitement for LLMs normalizes, we'll land on something evolutionary rather than revolutionary. Prompt programming will take over what used to be quick/amateur micro programs (this includes userspace "developers"). Skilled developers will operate on a spectrum: all manual code at one extreme, and at the other extreme, manually defining just the essential patterns that prompt programming can reasonably build upon.

I do not suspect that we will stay in an individualized programs Tower of Babel situation, if we ever enter it in the first place.

It's anyone's guess as to what we end up settling on, of course. This is just a guess of mine.

"Why hire a website designer when you could just drag and drop in WordPress?"

And many businesses do, and it works, until it doesn't. I agree with you; that's the future I'm seeing for ad-hoc LLM apps.

From what - OS libraires only? Assembly?

The danger is not "Nobody uses OSS".

The danger is "building software becomes exponentially more difficult without a commons to build from".

I don't think apps where people spend a lot of time are equivalent to small tools. You can vibe code a calculator but you probably spend most of your time on much more complex software.

LLMs have been a godsend for throwaway software. I wouldn't want to count the number of hours I've spent hand rolling an application that exists for one purpose for about two weeks and then to the digital graveyard.

Now that LLMs can do it while I make coffee, I can do more useful things with my time like writing business code and posting on HN.

Beyond that, meh.

Because it can’t really do that for any tools that matter.

This is only a realistic expectation for the single person who needs that hammer.

Otherwise we'll all individually be burning power via GPUs to reinvent the wheel thousands of times.

Also, look at the level of effort to maintain any bespoke machine. Assembly lines with interchangeable parts were a big deal for a reason. That follows with software via standard libraries and APIs. If you reinvent your software wheel every time, we'll all have careers trying to fix the deluge of slop that has been generated.

Exactly, think StarTrek replicator.

Why need a tool at all when the LLM can just build the house? What is a hammer? What is a keyboard? What’s a “Drivers License”?

Because going to the shed to get a work-tested tool is still faster than waiting on an LLM and hoping it meets every use-case you're likely to run into with that tool.

Whatever it is, the future will also certainly not be what it was a couple decades ago - that is, every one inventing their own solution to solved problems, resulting in a mess of tools with no standardization. There is a reason libraries/frameworks/etc exist.

> when LLMs can build you a custom(!) hammer or saw in a few minutes, why go to the shed?

once such LLMs exist, this question may be worth considering

they do NOT exist at this moment

along that line of thinking, I've been wondering if there are better building blocks. right now we're asking llms to use the bricks designed for the human hand building a cathedral - what do the bricks look like when we want AI to build many sheds for specific use? functional programming? would the database ideas of data storage like the longhorn vapourware make a come back?

[dead]

[dead]

I think that's an optimistic interpretation of how good LLMs are?

But I think the reality is: LLMs democratise access to coding. In a way this decreases the market for complete solutions, but massively increases the audience for building blocks.

I like this take. "How things are today + LLM" is in some ways the best we can approximate because one is all we know and other side is the future unfolding before our eyes. One of the coolest things about vibe coding I find is starting with a base like django then using vibe coding to build models and templates exactly how one wants for a UIUX. Basically maybe we still need humans for the guts and low level stuff but that provides a base for fast, easy personalized customization.

I had a job where in short we had a lot of pain points with software that we had no resources permitted to fix them. With a mix past experience, googling I started writing some internal web based tools to fix these gaps. Everyone was happy. This is where I see vibe coding being really helpful in the higher level stuff like higher level scripting and web based tools. Just my opinion based on my experience.