The incentives for software development are somewhat broken.

In the "old" days, there was an infinite amount of basic software to write (Operating Systems, file editors, compilers, etc.) and very few developers working on extremely expensive equipment. They had to write software that would just work, features were added based on need, and the idea of a continuous, high-effort, software development activity for a piece of software wasn't the rule. Once the job was done, the developers simply got paid and moved on. Updating, patching, etc was hard to do.

So the incentive was to deliver high-quality working software that did what it needed to do for decades without there being a continuous development effort to keep it "updated" because you only got paid by moving on to new jobs.

Today, the theme is CI/CD, which translates into "figure out how to keep an overstaffed engineering department occupied long after they delivered the working system". This translates into shipping broken, buggy, incomplete, software with the intention to keep the department occupied over the long-term with bug fixes, patches, feature updates and releases, and probably the occasional all-up rewrite. The industry says that the ideal form of this is to not only push releases every so often but to do it continuously in a never ending unbroken stream of work. But what happens when the software really is "done"?

The answer is that we see it all the time. Often in various forms of enshittification (i.e. rent-seeking). Feature reductions, refactoring parts of a perfectly working system stack, changing languages.

The incentive is to vertically integrate rent-seeking, companies are incentivized to seek new monetization sources (I want to say as a way to grow their business, but often it's to keep paying a crushing labor pool), down to developers who aren't incentivized anymore to ship-and-move-on. We also see other bizarre symptoms like taxi companies writing scalable message passing services and geospatial systems, or social networking companies building state of the art AI systems.

So here's an idea, what if the way it should work is thus?

- Developers are payed by the job, they pre-negotiate the price and the payment cadence (monthly, milestone, etc.)

- Groups of developers could form an Agency if they want to centralize the negotiating and business bits.

- Companies hire developers or Agencies for the job. A certain level of bug fixes are included in the contract. (x-number of months, so many bugs, certain number of hours, etc.)

- Feature updates are new jobs.

- Terms to include: "so long as we continue to use the software on our systems, the developers will get payed residuals." Modeled on how other Agency-based industries like acting or music continues to pay-out for use of the systems.

- Good developers can end up on a big passive income stream, and could either continue working in the industry, or perhaps start spending part of or all of their time working on open-source projects that could provide reuse across projects within their industry.

- The Best developers could go into a company, negotiate a nice contract, and the job could mostly be to yank the code out of a repo, compile, configure and run -- then collect passive income for the next few years as the company gets value out of that simple exercise.

It's not the effort of the developer that bring value to the company, it's the value of the solution, so why doesn't the industry incentivize that?