The scarce product may no longer be code. It may be a coherent, trusted, maintained opinion about how code should fit together.
Linux distributions do more than collect packages. They:
- select among substitutes;
- define compatible versions and defaults;
- remove or patch unsafe components;
- provide installation, upgrades, and rollback;
- establish conventions;
- test the whole system rather than each package independently;
- assume responsibility for keeping it working.
That is much closer to what people will need than another thousand standalone AI applications.
From app stores to capability distributions
An AI-era distro might not look like a bundle of applications. It could be a curated operating environment for a particular person or institution:
- A small-business distro: bookkeeping, payroll, contracts, email, scheduling, compliance, and customer support, all operating over one consistent model of the business.
- A clinical-practice distro: intake, transcription, coding, literature review, follow-up, and audit trails, with conservative privacy and verification policies.
- A research-lab distro: literature ingestion, experiment tracking, data analysis, code execution, provenance, collaboration, and publication.
- A household distro: purchasing, maintenance, travel, taxes, education, healthcare paperwork, and fraud defense.
- A software-team distro: issue triage, implementation, testing, deployment, incident response, dependency management, and architecture records.
The value proposition is not “we have an AI that can write emails.” Everyone will have that. It is:
This is a complete, opinionated, tested way of running a dental practice, research lab, or software organization—and someone trustworthy maintains it.
Users would interact primarily with their work and goals, not with a collection of apps. The underlying tools could be swapped out as models and vendors improve.
Curation becomes more technical, not less
Traditional software curation mostly asks whether packages install and interoperate. An AI distro must also govern behavior:
- Which models may see which information?
- Which sources count as authoritative?
- What can an agent do without approval?
- What evidence must accompany an answer?
- How is an action simulated or tested first?
- When must the system defer to a human?
- How are prompt injection and poisoned documents contained?
- Can every consequential action be attributed and reversed?
- How do we know an upgrade has not silently changed behavior?
That means the distro consists not only of code, but also of permissions, schemas, workflows, evals, provenance rules, organizational memory, and escalation policies. Its most valuable artifact may be its test suite for acceptable behavior.
This creates a meaningful engineering niche: people who turn unreliable, rapidly changing components into dependable systems.
Generated software may often be disposable
There is also a further step beyond curation. If models can cheaply generate software, some software need not exist as a permanent product at all.
You might say:
Reconcile these invoices against these contracts, show me discrepancies over $500, and produce a reviewable report.
The system generates a temporary program, runs it in a sandbox, preserves the inputs and audit trail, and then discards the implementation. You never discover, evaluate, install, learn, and maintain an “invoice reconciliation app.”
In that world, the durable product is the environment that safely generates temporary tools. The valuable components are:
- the user’s data model;
- the specification;
- the sandbox;
- the permission system;
- the verification machinery;
- the interaction design;
- the history and institutional memory.
So the distro may be less like Ubuntu shipping fixed binaries and more like an opinionated constitution for software generated on demand.↳ AI Can Use the Computer Better Than Me
Where the moat comes from
A loose collection of AI tools is easy to copy. A defensible distro would accumulate things that are harder to synthesize:
-
Distribution and trust
Users believe the maintainer will not exploit or abandon them.
-
Real workflow knowledge
It encodes all the ugly exceptions that a generic demo ignores.
-
Evaluation data
It knows what failures look like in a particular domain and tests for them.
-
Integration history
It works with the organization’s existing systems, records, and conventions.
-
Accountability
There is a legal and operational entity responsible for updates and failures.
-
Community governance
Users can inspect, contest, and influence consequential defaults.
Red Hat does not primarily sell access to Linux source code. It sells a reduction in organizational uncertainty. That remains valuable even if the raw ingredients cost almost nothing.
What this suggests for a software engineer
A promising career position is not “person who can emit code faster than the model.” It is maintainer of coherent capability.
Day to day, that might involve:
- observing how a particular profession actually works;
- formalizing tacit requirements and edge cases;
- choosing and replacing models and tools;
- constructing evals from real failures;
- designing authority boundaries;
- reviewing generated plans rather than every generated line;
- building simulations and adversarial tests;
- maintaining provenance and rollback;
- deciding which complexity should be hidden and which decisions must remain visible;
- taking responsibility for the behavior of the assembled system.
This favors a particular kind of generalist: not someone with shallow familiarity with everything, but someone who can rapidly learn a domain, communicate with its specialists, and then turn their knowledge into a reliable system. Deep specialists will still be essential, especially where correctness has a physical, financial, medical, or legal meaning. The productive unit may be a domain expert plus an engineering generalist plus AI, rather than a large conventional software team.
The opportunity, then, is probably not to add one more package to the infinite repository. It is to become the person—or organization—that can credibly say:
Ignore the infinite repository. Here is the small, coherent, safe subset that actually lets you do your work. We tested it, we maintain it, and we will be here when it breaks.