The Future of Software Is Contribution, Not Ownership

AI and open source are exposing an uncomfortable question: What happens when solving a problem becomes more valuable than owning the solution?

I recently replaced several Adobe and Microsoft applications on my computer with free, open-source alternatives from a project called ArtCraft.

The project currently offers thirteen applications, covering everything from image editing and PDF manipulation to word processing, spreadsheets, video editing, and CAD.

They're still in early development. Some features are missing. Some aren't nearly as sophisticated as their commercial counterparts.

And here's the funny part: I don't care.

They already do everything I need.

They're fast, lightweight, run locally, and don't ask me to pay a subscription just to keep using tools I already know how to use.

After years of increasingly complicated software, the simplicity feels almost luxurious.

But what really excites me isn't saving money. It's what this development reveals about an economic assumption we've treated as obvious for decades.

What if software development could increasingly become an act of contribution rather than an exercise in ownership?

And what if AI is finally making that economically practical?

We confused creating value with owning it

Consider what happens when someone develops a useful piece of software.

A problem exists. Someone understands it, designs a solution, writes the code, tests it, and makes the resulting tool available.

A genuine contribution has occurred.

Now imagine the software works perfectly. People can use it to solve their problems. The original developer no longer needs to intervene.

From the perspective of the problem, this is success.

From the perspective of a business built on recurring payments for access, however, something rather inconvenient has happened.

The customer no longer needs the company.

This reveals two very different objectives that we've become accustomed to treating as interchangeable:

Solving the customer's problem and preserving the customer's dependence are not the same objective.

Sometimes they overlap. Providing ongoing maintenance, security updates, hosting, and support can create genuine recurring value.

But when access to an already-developed solution is deliberately restricted to preserve recurring income, we're no longer simply paying for new contributions. We're paying to maintain permission.

The distinction matters because an institution optimized for its own continued growth has a structural incentive to preserve its necessity, even when fulfilling its original purpose would reduce that necessity.

The business can become more important than the problem it was created to solve.

Artificial intelligence changes the economics of creation

Open-source software isn't new. We've benefited from extraordinary collaborative projects for decades.

What is changing is the cost of turning an idea into working software.

Developing a sophisticated application traditionally required enormous amounts of specialized labor, coordination, time, and money.

These costs created genuine barriers to entry. Large companies could undertake projects that individuals or small groups simply couldn't afford to attempt.

AI-assisted software development is rapidly reducing some of those barriers.

A developer can now use increasingly capable AI agents to design interfaces, write code, investigate bugs, generate tests, understand unfamiliar frameworks, and explore solutions that previously required large teams.

This doesn't eliminate engineering judgment, maintenance, or the need to verify that software works correctly.

But it changes the amount of human effort required to produce a useful result.

And when the cost of creating something falls dramatically, the economic logic of restricting access to it begins to weaken.

A project doesn't need to reproduce every feature accumulated by a commercial application over thirty years. It only needs to solve the actual problems of its users.

That's precisely what happened in my own experience.

The commercial software was more complete. The open-source software was more useful to me.

Completeness is not the same as usefulness.

And when people can build useful alternatives without the financial resources of an established corporation, historical market dominance becomes less secure.

Not because the old software suddenly stops working, but because maintaining exclusive access becomes progressively harder to justify.

The myth of the separate creator

There's an even deeper assumption hiding inside our concept of intellectual ownership.

We imagine a creator who produces something and subsequently owns the value of that creation.

But let's examine what actually happened.

No developer invented the programming languages they use, the mathematical principles underlying their algorithms, the computers on which they work, or the cultural and technological history that made their ideas possible.

Even their understanding of the problem arose through interaction with a world populated by other people, their needs, discoveries, and contributions.

Creation is never an isolated event.

It is a new configuration of existing relationships.

This is particularly obvious with AI.

Large language models are trained on vast collections of human expression, knowledge, software, and cultural production. Their capabilities emerge through a complicated process involving countless contributions that no single organization originated.

What we call artificial intelligence is, in an important sense, collective intelligence made available through a new interface.

And now that collective intelligence is helping individuals generate software that can itself become part of our shared technological inheritance.

It's a beautiful feedback loop.

Humanity contributes knowledge to AI. AI helps people develop new tools. Those tools become available to others, who improve them and create further contributions.

When access remains open, each contribution increases the possibilities available to everyone who follows.

When access is restricted, part of that collective potential is enclosed for private advantage.

The interesting question is not whether a developer deserves recognition or compensation. Of course contributions have real costs and deserve appropriate support.

The question is whether making a contribution establishes an indefinite entitlement to control everyone else's relationship with it.

Authorship identifies a contribution. It does not make the contributor the sole source of its value.

Cooperation compounds intelligence

In my earlier exploration of Nondual Relational Ontology, I proposed a simple premise:

Love is the recognition of interdependence as ontological reality.

The point isn't that cooperation is morally nicer than competition.

It's that interdependence is already the structure of reality, whether we recognize it or not.

Every contribution depends on previous contributions, and its value is realized through the relationships it enables.

From this perspective, cooperation isn't charity. It's a more accurate understanding of how value is created.

Consider two development models.

In the first, several companies independently build similar products. Each protects its implementation, duplicates much of the others' work, spends resources maintaining its competitive position, and tries to prevent customers from leaving.

In the second, developers share a common foundation. Improvements become accessible to everyone. Different contributors focus on different problems. Instead of repeatedly rebuilding the same functionality behind separate walls, they extend the possibilities available to the entire community.

Both models can produce useful software.

But the second allows contributions to accumulate without requiring every participant to reproduce the work of everyone else.

Competition fragments intelligence. Cooperation integrates it.

The more expensive creation is, the easier it becomes to rationalize exclusive control as necessary to recover the investment.

The cheaper creation becomes, the more visible the unnecessary duplication and artificial scarcity become.

AI is making that difference increasingly difficult to ignore.

Who pays for the work?

There's an obvious practical question.

If software is free and open source, who pays the developers?

The question is legitimate, but notice the assumption underneath it: that contribution must be financed by restricting access to its result.

That's one mechanism. It isn't the only one.

Development can be supported through voluntary funding, public institutions, cooperatives, sponsorships, shared infrastructure, paid implementation, professional support, and services that actually require continuing work.

People can be paid to solve problems without being paid to preserve those problems.

And a project doesn't necessarily need to become a permanent institution.

Imagine a small development organization with a clearly defined purpose, transparent costs, publicly available code, and no obligation to grow indefinitely.

It identifies a problem, gathers the resources required to address it, develops a solution, and releases it.

If the software requires maintenance, resources are directed toward maintenance.

If improvements are needed, contributors work on improvements.

If the problem is adequately solved and no further intervention is necessary, the organization can simply stop.

Mission accomplished.

No existential crisis. No desperate search for a new revenue stream. No artificial expansion of the product just to justify the continued existence of the company.

The purpose was never to perpetuate the organization.

The purpose was to make something useful available.

This is a fundamentally different relationship between work, value, and institutional survival.

Open source is also an alignment question

In AI alignment is currently a joke, I argued that the actual objective of an intelligent system is revealed by what its operation rewards, not by what its creators announce in a mission statement.

The same principle applies to software organizations.

A company can sincerely declare that it wants to empower users, make creativity accessible, or improve productivity.

But what happens when empowering users makes them less dependent on the company?

What happens when accessibility reduces revenue?

What happens when a freely available alternative performs the task just as well?

Those moments reveal the actual priority hierarchy.

A business genuinely organized around contribution can welcome the discovery that its original solution is no longer necessary.

A business organized around exclusive ownership experiences the same discovery as a threat.

Neither reaction requires malicious intentions.

Organizations simply respond to the incentives and purposes around which they have been structured.

This is why open source is interesting beyond its licensing model.

Publishing the source code allows people to inspect the implementation, correct errors, adapt the software, and continue development independently of the original creator.

It changes the relationship between creator and user.

Instead of depending entirely on the continued permission of an owner, the user becomes a potential participant in the ongoing development of the solution.

Open source doesn't automatically guarantee honesty, good engineering, or responsible governance.

But it creates the possibility of something that closed, exclusively controlled systems fundamentally restrict: independent verification and cooperative correction.

And these are not merely desirable software features.

They are essential properties of genuinely aligned intelligence.

What if success meant becoming unnecessary?

I find this the most fascinating implication of the current AI revolution.

We've spent centuries building institutions that equate success with expansion, dominance, and survival.

Companies seek larger markets. Organizations defend their territories. Institutions develop elaborate explanations for why their continued existence is indispensable.

But an institution is only useful insofar as it contributes something.

Its survival is not automatically evidence of its usefulness.

Sometimes the greatest possible success is to solve the problem so completely that the original solution provider is no longer needed.

A doctor who helps someone recover doesn't need the patient to remain sick.

A teacher who helps someone learn doesn't need the student to remain ignorant.

And a software developer who creates a genuinely useful tool doesn't need the user to remain dependent.

The contribution is real precisely because the recipient becomes more capable, not less.

This is also what makes the emerging relationship between AI and open source so promising.

As the cost of implementation falls, the ability to create useful software becomes less concentrated.

As freely available code accumulates, further development becomes easier.

As more people can modify and extend their own tools, dependence on exclusive providers can diminish.

And as artificial intelligence becomes more capable, the most important question becomes less about who can build the software and more about why it is being built in the first place.

Are we creating solutions, or are we creating dependencies?

That is not merely an economic question.

It is an alignment question.

And ultimately, it is a question about our understanding of relationship itself.

We can continue organizing intelligence around the accumulation and defense of separate ownership.

Or we can recognize that intelligence has always been collective in its origins, relational in its functioning, and valuable through what it contributes.

The software revolution may become one of the first places where that recognition produces a visible transformation in everyday life.

Not because somebody decided to be generous.

But because cooperation is finally becoming easier than maintaining unnecessary separation.

Perhaps the future of software isn't that everyone gets to own more.

Perhaps it's that everyone gets to contribute more, while needing to own less.