When we build software by hand, a system’s capability maps almost one-to-one to the functions we implement: if it isn’t written, it can’t be done. Large language models point to a different path. Instead of enumerating functions, we define objectives, curate and generate data, design training and evaluation, and let the model learn capabilities from feedback. The artifact is still software, but the production method has changed: engineers shift from implementers to cultivators, closing the loop among goals, data, and measurement.

At scale—more parameters, more diverse data, longer training—models exhibit abilities we never explicitly enumerated. That isn’t magic; it’s the boundary of generalization being pushed outward. The ceiling on what software can do is no longer set only by how many APIs we hand-craft, but by how well we shape the objective–data–evaluation loop.

Here the natural metaphor is powerful. Hundreds of millions of years ago, DNA didn’t need to be understood to create value. It only needed three properties—copy, variation, selection—and under environmental pressure those mechanics accumulated complexity, producing a thriving biosphere. Software in the model era is assembling its own “digital DNA”: objective functions and constraints; data distributions and generation strategies; evaluation and safety criteria; reusable representations and operator libraries. Once this copy–mutate–select machinery closes at the ecosystem level, capability begins to compound.

That compounding is the key. Better models yield better synthetic or filtered data and sharper metrics; those in turn train better models. If we forecast with a ruler from today’s capabilities, we’ll likely underestimate the curve. The practical question is which bottlenecks bind—and when they open: compute, data quality and labeling, optimization and algorithms, safety and alignment. Each unlock can steepen the trajectory again.

For now, training pipelines remain largely human in the loop. People set goals, audit datasets, design evaluations, and enforce safety boundaries. Yet models increasingly participate in their own improvement: generating or filtering data, running automated evaluations, assisting in distillation of successors, acting as tools inside training and retrieval pipelines. This blend—HITL plus model participation—accelerates the self-improving loop.

Over a longer horizon, more abundant compute will likely settle into ubiquitous model intelligence, infrastructure as accessible as water or power, invoked across devices and contexts. From a user’s perspective, you provide intent and receive results; orchestration, code synthesis, kernel fusion, scheduling, and resource allocation happen behind the scenes. The distance between input and output shortens, even as the system’s internal sophistication grows.

None of this makes classical engineering obsolete. If anything, systems design, interface contracts, concurrency and networking, storage and consistency, observability and reliability matter more. They define the “physics” of the digital ecosystem—setting the cost of replication, the bounds of mutation, and the direction of selection. Those who grasp these fundamentals are better positioned to shape objectives, construct data distributions, design evaluations and safety guardrails, and judge when to compress complexity and where a reliable base must remain.

Which brings us to human purpose. Machines will excel ever more at the how. Our comparative advantage concentrates on deciding what to pursue, why it matters, and where the boundaries should be—embedding safety, governance, and public benefit into the loop. If we hold to those responsibilities, software’s “DNA” will self-improve along a trajectory we set, compounding on a governable track. The space between intent and outcome will keep shrinking, while our horizon—and our sense of limits—widens.