The Core Should Be Boring. The Edges Should Be Wild.
Jet Boots for Jumping in the Age of Software Abundance
I recently came across a wonderful little story about an inexpensive Chinese electronic synthesizer that has become an unlikely proving ground for the future of software development.
The device is called the M-VAVE FM-1. It’s a pocket-sized musical instrument costing roughly $60–70 USD, with a small colour screen, 27 miniature piano keys, eight knobs, and enough processing power to reproduce some of the sounds of the legendary Yamaha DX7 synthesizer.
The sort of thing a musician might pick up on a whim, play with for a while, and eventually consign to a drawer.
Except the FM-1 has escaped the confines of its original design, and the way it happened is particularly interesting.
Beginning in July 2026, enthusiasts on Reddit’s r/synthdiy community began reverse-engineering its firmware, the software that controls the instrument’s hardware. By September, people were releasing entirely new implementations, turning the humble little synthesizer into drum machines, multitrack sequencers, samplers, and all sorts of peculiar electronic instruments.
A project called Felucca became a particularly popular foundation, spawning further variations and experiments. Another, SLOOP, transformed the device into a pocket-sized music production studio. Others recreated classic electronic instruments, while somebody inevitably answered that most ancient and important of computing questions: Will it run Doom?
Yes. It runs Doom.
And a considerable portion of this activity has been facilitated by AI coding assistants.
The Ars Technica account of the phenomenon makes for delightful reading. What began as a fairly ordinary piece of inexpensive music hardware had, within a few months, become the centre of a flourishing little development ecosystem. Musicians, hobbyists, experienced firmware developers, and people employing AI to bridge their own programming knowledge gaps were collectively discovering that the same physical instrument could become almost anything its hardware permitted.
Then something even more interesting happened.
Rather than treating this spontaneous community of firmware hackers as a threat, M-VAVE embraced it. In October, the company released FM1 Open, publishing its application source code, a software development kit, and a browser-based workbench that allows people to explore and test firmware before deploying it onto the device.
The licence is GPLv3 with a linking exception, rather than an entirely permissive open-source licence, and the underlying sound engine remains proprietary. Nevertheless, the manufacturer has substantially reduced the obstacles facing people who want to repurpose its product.
This is a rather clever business decision.
M-VAVE no longer needs to anticipate every conceivable use for its hardware, nor does it need to employ a development team to satisfy the particular musical enthusiasms of every customer. It can provide a capable, inexpensive physical foundation and allow a community of increasingly empowered creators to explore the possibilities.
An instrument that might otherwise have been discarded or replaced after its novelty wore off can instead acquire new capabilities, new personalities, and entirely new purposes. The manufacturer benefits from the growing utility of its hardware, while the community benefits from a shared platform and from being able to build upon one another’s work.
There’s even an instructive wrinkle in the story. Firmware experimentation carries the risk of rendering the device unusable, and newer hardware revisions have introduced compatibility problems for some community projects. The creative explosion is genuine, but so are the consequences of unreliable foundations and poorly tested changes.
I find this enormously exciting, not merely because I love open-source software and eccentric little computers, but because it illustrates an emerging architectural principle with implications far beyond electronic music.
The core should be boring. The edges should be wild.
And with generative AI dramatically lowering the cost of creating specialized software, I suspect this principle is about to become considerably more important.
The old bridges across the software capability gap
Traditionally, organizations have had only a handful of viable options for getting software to do what they need within a reasonable, palatable budget.
They could purchase commercial software and adapt their operations to its assumptions, commission bespoke development and absorb the expense, or adopt a reusable platform that already provided most of the necessary functionality and customize the remainder.
That last approach has been one of the most successful mechanisms for closing software capability gaps.
Software development has been infamous for cost and timeline overruns for as long as I’ve been involved in the industry. A 2012 McKinsey and Oxford University study found that large IT projects in its dataset averaged 45% over budget and 7% over time, while delivering 56% less value than predicted. The historical figures shouldn’t be mistaken for a contemporary prediction, but they illustrate the extraordinary costs that traditional approaches could impose.
Agile software development, whose guiding principles remain foundational to how we work at Opreto, emerged partly as a response to the brittleness of those traditional approaches. Rather than pretending we could define all requirements perfectly in advance, we learned to iterate, collaborate, deliver working software, and adapt continuously to what we discovered.
Another powerful response was architectural: stop reinventing the common parts of software every time somebody needed something slightly different.
Open-source frameworks, extensible application architectures, and eventually the commercial model often called open core allowed organizations to share the enormous expense of building and maintaining generalized software foundations.
Examples abound.
Apple’s macOS incorporates the XNU kernel, drawing upon the Mach microkernel and BSD Unix traditions. Google’s Chrome builds upon the open-source Chromium project, which also underpins competing browsers such as Microsoft Edge and Brave. Android combines the Linux kernel and a substantial open-source operating-system foundation with manufacturer-specific adaptations and, frequently, proprietary services.
Enterprise software offers related examples in Odoo, with its Community and Enterprise editions, and ERPNext, an open-source business application platform that can be extended for particular operational requirements.
These aren’t identical software licensing or distribution models, but their underlying economics are similar.
Build the common 90% once, then allow people to customize the final 10% without repeatedly rebuilding the same foundational functionality.
This approach has benefited from the collective development and scrutiny of open-source communities, famously described by Eric S. Raymond in The Cathedral and the Bazaar. Mature shared software can accumulate decades of testing, documentation, security improvements, and operational knowledge, much of which would be prohibitively expensive for any individual organization to reproduce.
There is also a philosophical dimension to this, which I explored in an earlier article about federated software systems. Shared foundations and interoperable protocols allow organizations to participate in larger technological ecosystems without necessarily surrendering their autonomy to the owners of proprietary silos.
The principle is that a rising tide lifts all boats, and the collective improvement of common infrastructure can leave everyone better equipped to pursue their own distinct objectives.
Unfortunately, the economic advantages of this model have often come with a stubborn limitation.
Even when the foundation was free, customizing it required expensive expertise.
A business might save hundreds of thousands of dollars by adopting an existing platform, only to discover that its particular workflows, equipment, regulatory obligations, or organizational peculiarities still demanded substantial professional development.
The final 10% could remain spectacularly expensive.
What happens when the final 10% becomes inexpensive?
Earlier this year I wrote about the Age of Software Abundance, describing my experiences supervising several AI coding agents simultaneously across repositories, infrastructure, and experimental applications.
What struck me most wasn’t simply the improvement in programming productivity, but the collapse in the cost of experimentation.
An idea that previously wouldn’t have justified a development sprint could now be explored in an afternoon. Small integrations, temporary dashboards, custom automation tools, and peculiar little applications became practical simply because the cost of initiating and iterating upon them had fallen so dramatically.
I compared it to the Industrial Revolution, when mechanized textile production transformed cloth from an expensive commodity into something ordinary people could acquire in unprecedented quantities.
Our digital closets are beginning to fill.
But there’s a troubling possibility lurking within this abundance.
The language models enabling this revolution have learned programming patterns from vast bodies of existing software and documentation, much of it derived from the very open-source ecosystems we’ve spent decades developing.
And now we’re using that accumulated knowledge to generate an astonishing quantity of new, seemingly bespoke implementations of functionality that may already exist.
Consider ten thousand organizations that all need approximately the same inventory management system. Historically, our best solution was to share the foundational functionality and customize the particular business processes.
In the age of AI-generated software, we could instead produce ten thousand independent inventory applications, each with its own data models, dependencies, security assumptions, maintenance obligations, and undiscovered bugs.
This is a peculiar form of technological regression, disguised by the astonishing speed at which the new implementations appear.
And the costs aren’t exclusively financial. The enormous expansion of AI infrastructure has brought legitimate concerns about electricity consumption, water usage, environmental consequences, and whether the benefits of all this computation justify its increasingly substantial footprint. Generating endless disposable implementations of solved problems hardly seems like the most responsible way to use those resources.
There’s also an emerging social cost within software development itself. Generating code is becoming faster than understanding it, and the burden of reviewing and maintaining that code doesn’t automatically diminish alongside the effort required to produce it.
This is precisely why the FM-1 story is so encouraging.
The enthusiasts didn’t each need to manufacture a new synthesizer to pursue their musical ideas. They inherited a common physical platform, and many built upon the firmware and discoveries of earlier contributors.
The creative possibilities multiplied without requiring the underlying hardware to be independently reinvented for every experiment.
What if we deliberately built business software around that same relationship between reliable shared infrastructure and inexpensive, radically customizable functionality?
The boring core, in the real world
My cofounder Aaron Mavrinac has spent much of his professional life working with software that interacts with the physical world, including robotics, computer vision, embedded systems, and industrial automation.
These are fields in which the relationship between dependable infrastructure and specialized functionality is particularly important, because the consequences of a software error can extend considerably beyond a broken web page.
Aaron has been leading the development of Kinoptyx, an emerging Opreto software foundation for spatial intelligence in industrial robotics and machine vision.
Kinoptyx addresses a set of problems that recur across an extraordinary range of automation applications.
Consider something apparently straightforward: a manufacturing company wants to use a camera to locate parts on a workbench so that a robot can pick them up.
The camera can see the parts. The robot can move its arm. Presumably, making the robot pick up what the camera sees should be simple.
Except the camera and robot don’t actually understand the world in the same way.
The camera sees an object at a particular location in an image, measured in pixels. The robot understands movement in terms of distances, angles, and positions relative to its own base and joints. The workbench occupies another physical position, while the gripper attached to the robot has its own geometry and operating constraints.
Even after a vision system determines where the object is in three-dimensional space, that location must be translated into a position and orientation the robot can use. The software needs to know exactly where the camera is mounted, how its lens distorts the image, how the robot relates to the surrounding machinery, and whether any of these relationships have changed since the system was last calibrated.
And these measurements aren’t perfect. Cameras introduce distortion, sensors have limited precision, and physical equipment is not always installed in precisely the position anticipated by its original design.
This is the sort of problem that can consume an enormous amount of specialist engineering effort before the robot ever picks up its first part.
Now imagine doing it again for another customer, with a different robot, a different camera, and a different arrangement of equipment.
Much of the application will be unique, but the underlying problems involving geometry, calibration, coordinate transformations, and spatial uncertainty are fundamentally the same.
That’s the opportunity Kinoptyx is pursuing.
At the heart of the system is something called a station model, essentially a digital representation of the physical workspace. It describes the objects and equipment present, how they relate to one another, and the positions and orientations needed to understand the space.
Alongside that representation is the mathematical machinery that allows the software to translate between different coordinate systems. If a camera reports the position of an object, and the system knows the camera’s relationship to the robot, it can determine where that object lies in the robot’s own frame of reference.
Calibration and optimization algorithms help establish and refine those relationships using real measurements, accounting for the fact that the physical world rarely conforms perfectly to the assumptions in a computer model.
And finally, software adapters provide the connections to actual equipment. A camera manufactured by Cognex, a robot manufactured by ABB, and a controller communicating over an industrial network may all have different interfaces, but they shouldn’t each require an entirely new implementation of the underlying spatial mathematics.
For readers familiar with robotics, the architecture uses technologies such as ROS, the Robot Operating System middleware ecosystem; its TF conventions for tracking coordinate transformations; and the Ceres optimization library. The team is deliberately separating its underlying C++ spatial model from the ROS services and visualization components, allowing the foundational capabilities to be reused in different environments.
The details matter to the engineers developing it, but the conceptual arrangement is relatively straightforward.
Rather than building a complete, specialized automation application from scratch for every customer, we want to provide the common spatial intelligence and the tools for connecting it to particular machinery.
One manufacturer might need robotic picking. Another might need a vision-based inspection system. A third might need to calibrate several cameras watching the same production line.
The resulting applications can be very different without requiring independent implementations of the mathematics and underlying machinery that make them possible.
There’s considerable engineering discipline involved in deciding which capabilities belong in that common foundation, which should be delegated to established libraries, and which should remain specific to the applications built on top.
And we’ve already encountered an instructive example within our own development work.
During a November review of Kinoptyx’s early C++ pull requests, Aaron and the team were examining supporting code for the ROS-facing configuration system, including functions used to validate settings and naming conventions. This is the sort of unglamorous plumbing that every substantial software project accumulates: making sure configuration values are valid, identifiers follow the expected rules, and different components can reliably understand one another.
An AI coding assistant had produced an implementation of one naming-validation problem that ran to roughly two hundred lines, despite the underlying requirement being something a regular expression could handle. Elsewhere, a proposed change included colour-conversion functionality that was already available through established libraries.
Neither was a disastrous production failure. These were ordinary proposed changes being examined through ordinary engineering review, which was doing exactly what it was supposed to do.
But the episode illustrated a subtle problem with AI-assisted development. When generating another implementation becomes trivially inexpensive, the agent may find it easier to manufacture a fresh solution than to investigate whether a suitable one already exists.
The team consequently raised a development ticket, memorably titled Have Claude Stop Reinventing Things, to tighten the instructions supplied to coding agents. The approach wasn’t to prohibit new code or automatically import dependencies whenever something looked familiar. It was to have the agents investigate appropriate maintained libraries, consider their size and quality, and present sensible options for human engineering judgment.
Aaron’s aim was to keep Kinoptyx focused on the specialized spatial-estimation functionality that actually distinguishes it, rather than gradually accumulating a collection of bespoke implementations of commodity software.
I think that’s an excellent example of what competent software engineering looks like in an age when code itself is no longer particularly scarce.
The important contribution isn’t necessarily another two hundred lines of code. Sometimes it’s knowing why those two hundred lines shouldn’t exist.
Now consider what happens if we expose the legitimate customization points of this foundation to AI-assisted development.
A machine builder could use a coding agent to implement support for an unusual camera, generate a specialized calibration workflow, or assemble a customer-specific automation application from the existing capabilities.
The shared mathematical infrastructure remains under deliberate engineering control, while the application-specific software becomes much easier to produce. The builder retains its expertise in the machinery and manufacturing process, rather than being required to become an expert in every aspect of computer vision and robotics software.
And a useful new adapter could eventually be generalized, tested, and shared for reuse by other builders.
Kinoptyx isn’t yet a public, agent-extensible platform of this sort. Today we’re developing its reusable foundation and using that work to support project-specific automation solutions. But it illustrates a promising direction, and one that aligns remarkably well with the wider changes taking place in software development.
Greenhouses, enterprise software, and the tyranny of the last mile
I’ve been thinking about similar problems from a rather different direction.
As I described in 3+ Ways Greenhouses Will Save the World, my own interest in controlled-environment agriculture has deep personal roots. I grew up around farming, and although my career took me into computers, I’ve always remained something of an IT farmer at heart.
At this year’s Canadian Greenhouse Conference, one particularly interesting theme was the difficulty smaller greenhouse operators face finding business software that actually suits their needs.
A greenhouse is a peculiar kind of factory.
Its production machinery is biological, its operating environment must be continuously managed, and its production processes depend on an assortment of climate controllers, irrigation systems, nutrient delivery equipment, labour management practices, crop records, inventory systems, and logistics arrangements.
Many greenhouse operators have assembled these capabilities incrementally, purchasing equipment and software as circumstances demanded, and filling the gaps with spreadsheets, manual processes, and increasingly elaborate workarounds.
Larger operators can justify sophisticated commercial systems and expensive integration projects. Smaller, family-operated producers often cannot, despite having operational requirements that aren’t necessarily simpler.
A small greenhouse may have older but perfectly serviceable irrigation equipment, a modern climate controller, specialized crop management requirements, and an inventory process that doesn’t resemble anything anticipated by a conventional ERP vendor.
A comprehensive commercial solution might be prohibitively expensive, while developing something bespoke would traditionally have been absurd.
This is precisely the sort of capability gap that an AI-extensible shared platform could address.
We could begin with an established open-source business application foundation, such as ERPNext or Odoo, rather than writing an entire ERP from scratch. Around that foundation, we could develop reusable agricultural components for production records, crop planning, traceability, equipment integration, and the other common requirements of controlled-environment agriculture.
Individual producers could then extend those capabilities to accommodate their particular workflows and equipment.
An operator shouldn’t need to replace a functioning piece of machinery simply because the software vendor doesn’t support its communication protocol. Nor should it need to hire a conventional software development team to create an unusual production report or integrate a particular sensor.
And if one grower develops a useful integration for a particular climate controller, why should the next grower have to commission it again?
Connecting a reporting dashboard to greenhouse telemetry is, of course, a different proposition from allowing generated code to control nutrient delivery pumps. The former is an obvious candidate for inexpensive customization; the latter requires additional engineering, validation, and operational safeguards.
We’re exploring how to approach controlled-environment agriculture at Opreto, including the possibility of building reusable platform components and working directly with growers to develop and validate them. The associated Canadian funding opportunities are interesting in their own right, but the architectural proposition is global. The same approach could serve producers in Ontario, the Netherlands, Mexico, Kenya, or anywhere else that specialized operational requirements collide with the cost of traditional enterprise software.
Beyond industry and agriculture
Healthcare and education present other variations on the same problem, and both are areas in which Opreto’s team has considerable experience.
We’ve helped modernize telemedicine and healthcare language-access systems, including the Martti platform for UpHealth, where architectural improvements helped reduce application startup time by 92% while supporting a more scalable and dependable service.
Healthcare software must accommodate an extraordinary diversity of clinical and administrative workflows, but the foundational requirements surrounding patient privacy, identity, auditability, and system reliability are shared across many applications. A common telemedicine foundation could provide those capabilities while enabling healthcare organizations to develop specialized scheduling, interpreter dispatch, intake, accessibility, and follow-up workflows.
In a regulated environment, the distinction between the two layers is particularly consequential. An experimental scheduling interface should not have the same authority as a component handling patient records or clinical decision-making.
Education has different constraints, but a similar architecture could be useful. Members of our team have longstanding experience with large-scale assessment and learning platforms, including student rostering, test delivery, and scoring systems.
Standards such as QTI and OneRoster already provide mechanisms for sharing educational content and information across systems. A dependable assessment platform could build upon these standards while allowing educators and institutions to develop their own learning interfaces, reporting tools, and curricular experiences.
The interesting opportunities in these industries aren’t necessarily to build entirely new monolithic platforms. Much of the foundational work has already been done, and in some cases standardized across an entire industry. It’s the cost of adapting that infrastructure to local requirements that remains prohibitive.
AI-assisted development could make those adaptations practical, provided that the foundational systems remain trustworthy.
And we’re now seeing the consequences of failing to manage that distinction play out within one of the most consequential shared software projects in the world.
Linux, Git, and the limits of human-scale development
The Linux kernel underpins an extraordinary proportion of modern computing, running everything from smartphones and industrial equipment to enterprise infrastructure and the cloud services that power much of the internet.
It’s also an excellent illustration of the peculiar tension between innovation and maintainership.
In fact, the Linux community has already lived through at least one fundamental crisis in the economics of software collaboration, and its response produced one of the most consequential development tools of the modern era.
When Linus stopped scaling
Linux began in 1991 as a project largely developed by Linus Torvalds himself, but its growing success quickly attracted contributions from developers around the world.
In the early years, those contributions were commonly exchanged as patches, essentially descriptions of changes to the source code, delivered through email and mailing lists. Torvalds reviewed and integrated them, initially sometimes rewriting contributions himself before gradually learning to trust other developers’ work.
As the project expanded, this arrangement became increasingly difficult to sustain.
By the turn of the millennium, Linux had become a substantial commercial and technical undertaking, with developers working on hundreds of different components across the world. Torvalds became a bottleneck in the integration process, and the limitations of the existing development workflow were increasingly apparent.
In a 2016 IEEE Spectrum interview, he recalled the criticism that emerged around this period: Linus doesn’t scale.
The problem wasn’t simply that developers needed somewhere to store source code. They needed a way to work independently, preserve the history of their changes, combine parallel development efforts, and reliably integrate contributions into a shared project without making one person responsible for coordinating everything.
In 2002, the kernel community began using BitKeeper, a proprietary distributed version-control system that offered substantially better support for this kind of work. It allowed developers to maintain their own copies of the project, collaborate within smaller groups, and submit completed changes through a hierarchy of trusted maintainers.
BitKeeper was controversial because Linux was an open-source project relying upon a proprietary tool, and that relationship ultimately broke down in 2005 following disputes involving its licensing and reverse engineering.
Torvalds, unwilling to return to the old development model and dissatisfied with the available alternatives, decided to create a replacement.
The result was Git.
The initial implementation took him roughly ten days to make usable for Linux development, although he’d spent months thinking about the underlying design. In a 2025 interview celebrating Git’s twentieth anniversary, Torvalds emphasized that the brevity of the implementation effort shouldn’t be confused with the absence of substantial design work.
Git was built around the needs of a large, distributed software project: efficient branching, merging, reliable history, and the ability for contributors to work independently without depending upon continuous access to a central authority.
Developers could experiment in their own repositories, maintainers could integrate changes within their areas of responsibility, and the resulting work could eventually make its way into the main Linux kernel.
Git didn’t invent distributed software development, and it certainly didn’t eliminate the need for careful review. But it transformed the economics of coordinating a large development community.
Twenty-one years later, it has become so ubiquitous that most developers can scarcely imagine working without it.
The Linux Foundation’s account of kernel development explicitly identifies distributed, hierarchical development and appropriate tooling as essential to the project’s ability to scale.
This history is particularly relevant now because the kernel community is encountering another development-velocity problem. Once again, the ability to produce contributions is beginning to outstrip the capacity of established tools and human processes to manage them.
Except this time the additional contributors aren’t exclusively human.
New languages, new agents, old responsibilities
For years, the Linux community has been engaged in a sometimes acrimonious debate about introducing Rust into a kernel traditionally written almost entirely in C.
Rust offers memory-safety properties that can eliminate certain classes of vulnerabilities, making it attractive for systems programming. But introducing another language into a mature project has consequences beyond the technical merits of that language. It requires new tooling, additional expertise, changes to interfaces, and maintenance commitments from people who may have spent decades working within the established architecture.
The controversy became especially public in 2025, with disputes over how Rust code should interface with existing C subsystems. Hector Martin, a prominent contributor to the Asahi Linux project, eventually stepped away amid disagreements and burnout.
The resulting Rust-for-Linux policy sought to reconcile these interests by establishing clearer expectations around integration and maintenance.
The underlying problem wasn’t whether Rust could produce useful code. It was how to introduce a new capability without imposing an unreasonable burden upon the people responsible for keeping existing systems dependable.
Which makes the kernel community’s more recent encounter with AI-assisted development particularly fascinating.
Linus Torvalds has been openly receptive to AI as a software development tool, while remaining characteristically unsentimental about the quality of the results. In July 2026, he weighed in on the use of AI-assisted code review, making clear that Linux wasn’t going to prohibit useful AI tools simply because their output could sometimes be incorrect.
By October, he was experimenting with Claude Code himself, using it to help produce performance-oriented patches for Linux memory management.
The initial results were promising, although subsequent review identified a race condition requiring further work. An instructive outcome: AI had helped generate potentially valuable optimizations in an exceptionally specialized part of the kernel, but the ordinary mechanisms of review remained essential.
Meanwhile, AI-assisted vulnerability discovery was contributing to a dramatic increase in the volume of security work.
At the Kernel Recipes conference, Greg Kroah-Hartman described the accelerating rate at which kernel vulnerabilities were being discovered and addressed. According to LWN’s account, the kernel was fixing roughly 33 CVEs per day, with the number of fixes per release having increased substantially.
An increase in vulnerabilities being reported and repaired doesn’t necessarily mean the software has become less secure. Many of these defects may have existed for years, escaping detection until more powerful analysis tools exposed them.
The broader security industry also experienced an unusually eventful October 2026, widely described as Black October, with serious vulnerabilities and security incidents affecting several major software ecosystems. These weren’t all Linux vulnerabilities, nor were they all discovered using AI, but they contributed to a growing awareness that our capacity to discover problems may be accelerating faster than our traditional ability to process them.
And the human cost is becoming apparent.
In November, Linux memory-management expert Lorenzo Stoakes stepped back from several additional kernel review responsibilities, citing the volume of AI-generated patches arriving for his attention. He remained a maintainer, but could no longer reasonably absorb the expanding review workload.
The economics are straightforward, and rather ugly.
An AI-assisted contributor can generate a proposed patch in minutes, while an experienced maintainer may need hours to understand it, determine whether it actually solves a problem, evaluate potential regressions, and decide whether the change belongs in the kernel at all.
We have dramatically reduced the cost of producing submissions without proportionally reducing the cost of reviewing them, and the resulting imbalance is being borne by some of the most experienced developers in the ecosystem.
There’s also a genuine risk that this process damages the open-source commons upon which so much of the AI revolution depends. Maintainer attention is a finite resource, and making it inexpensive to impose additional work upon volunteers is not an especially sustainable way to organize software development.
Yet there are signs that the situation needn’t remain this way.
During the Linux 7.4 development cycle, Torvalds reported an unusually large volume of changes, approaching 20,000 commits compared with a more typical 15,000, with AI-related fixes contributing to the increase.
More encouragingly, in his November 8 announcement for Linux 7.4-rc2, he relayed an observation from the BPF subsystem that AI-assisted fixes appeared to be arriving faster than newly reported problems.
He was appropriately cautious about extrapolating that experience across the kernel, but the implication is intriguing.
There may be a transition underway, from an initial period in which automated discovery and code generation overwhelm maintainers, toward one in which the same technologies help identify, reproduce, repair, and verify problems efficiently enough to improve the underlying software faster than new defects accumulate.
The kernel community is experimenting with AI-assisted review tools and additional processes for screening contributions before they reach maintainers. Such tools won’t eliminate the need for experienced developers, and their own findings require scrutiny, but they could substantially reduce the burden of processing routine defects and poorly prepared submissions.
And outside the kernel community, some of the companies developing these AI systems have already encountered scaling problems serious enough to require fundamental changes to their own development infrastructure.
The next Git moment?
In October 2026, Anthropic published a remarkable engineering account titled Redesigning Source Control at Anthropic.
The company described how its internal use of Claude had dramatically increased the amount of software being produced, with daily merged changes rising from approximately 2,500 in May to more than 30,000 by September.
This wasn’t simply a matter of developers typing faster. Agents were operating in parallel, generating changes, running experiments, and invoking automated development processes on a scale for which much of the existing infrastructure had never been designed.
Anthropic’s main repository had also become enormous, with nearly 100 gigabytes of history on its primary branch. The company’s testing and development systems were performing roughly 25 million code checkouts per day, even before accounting for every interactive development environment.
Git was never intended to be operated quite like this.
One of its great strengths is that each developer can maintain an independent copy of a repository, with enough information to examine history, create branches, and perform many operations without relying on a central server.
But Anthropic realized that these capabilities, which had made Git so valuable for human developers, were not necessarily appropriate for an enormous population of agents and automated jobs that were almost always connected to the company’s internal infrastructure.
Rather than continuing to expand its fleet of Git servers and workarounds, Anthropic built a new source-control system called Scion, migrating its monorepo from Git over a period of approximately five months.
Scion takes a substantially different approach. Much of the work that Git traditionally allows a developer’s computer to perform independently is handled by scalable server infrastructure, while agents and development environments retrieve only the information they actually need.
Alongside Scion, Anthropic built a new code-review system called Antique, as well as supporting infrastructure for searching code, managing permissions, and processing very large numbers of changes.
The company reports that the new infrastructure has dramatically reduced the computational resources required to manage its codebase while accelerating the development and testing processes that depend upon it.
Interestingly, Anthropic is quite explicit that Scion isn’t a suitable general replacement for Git. Its design reflects the unusual conditions of a company operating enormous internal repositories with extraordinary quantities of AI-assisted development.
But Anthropic isn’t the only company confronting these pressures.
On November 2, OpenAI published its own account, Scaling Git at OpenAI, describing a similar problem arising from the expanding use of Codex in its engineering organization.
OpenAI’s response was different.
Rather than replacing Git entirely, it built a new backend called Pando, designed to support large numbers of simultaneous changes while preserving compatibility with existing Git tools and workflows.
The system allows more concurrent operations and more efficient distribution of repository data without requiring developers or their agents to adopt an entirely different version-control interface. OpenAI reports nearly a fivefold reduction in median push latency, with Pando now delivering almost a petabyte of Git data per day.
I find the contrast fascinating.
Two of the leading companies developing AI coding technology encountered similar problems as their own software development activity expanded beyond the assumptions of traditional infrastructure.
One concluded that its requirements justified replacing Git with a purpose-built system. The other chose to preserve the familiar Git interface while substantially replacing the machinery behind it.
Neither approach is inherently the correct answer for everyone. Both represent deliberate engineering responses to a real change in the scale and character of software development.
And both make something clear: the effects of AI-assisted programming extend beyond the code being written. They reach into the systems and processes by which software development itself is coordinated.
There’s an additional detail in Anthropic’s account that I particularly appreciate.
Despite building Scion and its supporting infrastructure at remarkable speed using Claude, the company’s engineers found themselves repeatedly having to reject AI-generated approaches that violated important architectural assumptions or introduced unnecessary complexity.
The work still required people who understood the system well enough to distinguish a clever implementation from a sensible design.
This recalls something Torvalds said in that Git anniversary interview: writing code is easy; getting the design right is what matters.
He was describing work he undertook two decades before the arrival of modern coding agents, but the observation seems remarkably appropriate today.
Git helped the Linux community overcome one generation of development coordination problems. Anthropic and OpenAI are now building infrastructure to accommodate another.
Neither example suggests that we should all rush out and replace our version-control systems, or that processing more changes automatically produces better software.
The deeper lesson concerns the relationship between development velocity and the infrastructure required to sustain it.
When the economics of producing software change, the processes governing software have to evolve as well.
For the Linux kernel, that includes finding ways to preserve the attention and judgment of experienced maintainers as the volume of proposed changes expands.
For companies building reusable software platforms, it suggests an opportunity to design those platforms around this new reality from the outset.
Bring Your Own Harness
This leads to an approach we’ve been exploring at Opreto, which we’re calling BYOH: Bring Your Own Harness.
An AI model isn’t a complete software development environment. To do useful work on a real codebase, it needs surrounding tools for inspecting repositories, modifying files, running tests, executing commands, and managing the development process. This surrounding machinery is generally called an agent harness.
Claude Code, OpenCode, Codex, Pi, and similar tools offer different approaches to providing those capabilities, often with considerable flexibility in the underlying AI models.
Because these technologies are evolving so quickly, building a software platform whose customization architecture depends exclusively upon one particular provider seems unwise.
Our idea is to provide a rigorously maintained software foundation with an extension development environment designed to accommodate whichever compatible harness a customer prefers.
Imagine purchasing or deploying a Kinoptyx-based automation system and discovering that you need support for a particular camera model.
Rather than commissioning an entirely new development project, you could open your preferred coding agent, point it at the platform’s extension development kit, and describe the required integration.
The agent would have access to versioned interfaces, reference implementations, hardware abstraction layers, relevant documentation, and executable compatibility tests. It could produce a proposed adapter, evaluate it against recorded sensor data or a simulated environment, and package the result for engineering review.
The shared spatial-estimation algorithms and coordinate transformation machinery wouldn’t need to be modified. The new functionality would interact with them through defined interfaces, with access to physical equipment governed separately.
For organizations that already employ developers or coding agents, the platform would provide familiar instruction files such as AGENTS.md and CLAUDE.md, alongside development tools that encode the actual architectural contracts.
Other organizations might prefer not to assemble their own AI development environment. For them, we could provide a supported, preconfigured harness as part of the platform: batteries included.
Depending on the application, that could mean a hosted development workspace or an isolated environment running locally, at the customer’s edge. The latter could be particularly useful where industrial data, proprietary processes, or regulatory requirements make external AI services undesirable.
The important engineering work lies in making the interface between customization and the shared platform explicit and enforceable.
An agent instruction file might explain which interfaces to use and which conventions to follow, but it cannot substitute for security boundaries. Automated contract tests, permissions, reproducible builds, code review, and deployment controls must establish what a generated extension is actually allowed to do.
There is a substantial difference between allowing an agent to generate a proposed robot-control extension in a simulated development environment and granting it the authority to execute arbitrary instructions on a production robot.
The platform needs to understand that difference even when the agent doesn’t.
We envision maintaining defined, verified platform releases with explicit support and compatibility commitments. These wouldn’t somehow guarantee that arbitrary AI-generated extensions were safe; rather, they would establish a dependable foundation and a set of mechanisms for evaluating compatibility and controlling how extensions interact with it.
A generated reporting interface could reasonably face different validation requirements from an adapter capable of moving a robot or modifying financial records.
The experiences of the Linux community, and now of Anthropic and OpenAI, suggest that these mechanisms will need to be designed around the realities of AI-assisted development rather than merely borrowed unchanged from conventional workflows.
Customers should be able to generate proposed functionality without automatically imposing an unlimited review obligation upon the maintainers of the core platform. Automated validation, reproducible tests, and clearly defined extension boundaries can absorb much of the routine work, leaving human engineers to concentrate on consequential design and operational decisions.
Successful customizations could remain private, or their creators could contribute generalized versions to a shared ecosystem. Useful contributions might eventually be incorporated into supported extension libraries or, when appropriate, the common foundation.
This wouldn’t be an entirely new software development methodology. It would be a deliberate application of established principles of modularity, testing, continuous integration, and open-source collaboration to a world in which code generation has become vastly more accessible.
The novelty lies in designing the platform from the outset to accommodate that accessibility, rather than treating AI-assisted development as an unpredictable activity occurring outside the architecture.
What becomes of the software company?
There’s an obvious commercial question embedded in this model.
If customers can use their own AI agents to develop extensions, and much of the foundational platform is open, what exactly does a company like Opreto sell?
I think the answer follows naturally from the experience of the Linux community and from our own work developing specialized software.
The ability to generate code isn’t the same as the ability to provide dependable infrastructure, particularly in environments where mistakes have serious consequences.
A machine builder might have exceptional expertise in its manufacturing equipment but little interest in maintaining geometric optimization algorithms. A greenhouse operator may know exactly what its production process requires without wanting to become responsible for enterprise authentication, data integrity, or integration infrastructure. A healthcare software provider may need highly specialized workflows while relying upon established and carefully maintained mechanisms for protecting patient information.
These organizations would benefit from greater autonomy over their software without necessarily wanting to assume responsibility for every layer of it.
That’s a commercially interesting position for Opreto.
We can provide reusable engineering foundations, specialize them for particular industries, maintain compatibility and security, and offer integration, verification, hosting, and operational support according to customer needs.
Some customers will want us to handle almost everything. Others may operate the platform themselves, use their own development harnesses, and require very little assistance beyond updates and occasional specialist support.
Our business needn’t depend upon making the latter group artificially dependent on us.
In fact, I’ve long believed that digital sovereignty and customer autonomy are competitive advantages rather than threats. If a customer can retain ownership of its data, source code, customizations, and deployment environment, then our continued involvement has to earn its value through the quality of the services and infrastructure we provide.
This also offers an attractive answer to a problem facing conventional software consulting businesses. If writing the last mile of software becomes substantially less expensive, continuing to charge primarily for the effort of writing bespoke code may become an increasingly difficult proposition.
But there remains considerable value in making software work reliably, evolve predictably, and coexist with the complicated systems organizations already depend upon.
The more affordable customization becomes, the more organizations may be able to justify using sophisticated software in the first place. That could expand the market for dependable platforms and specialized engineering, even as the economics of producing individual features change.
That’s the possibility I find interesting, rather than the rather depressing idea that AI will simply produce the same software with fewer developers and lower margins.
The core should be boring. The edges should be wild.
In my earlier essay about software abundance, I suggested that as the cost of creating software falls, discernment and stewardship become increasingly important.
The experiences of the Linux maintainers give that observation some rather uncomfortable substance. It’s possible to produce more code, discover more vulnerabilities, and propose more improvements than a project can reasonably evaluate. Without the processes to absorb that activity, what appears to be progress can become an obligation imposed upon somebody else.
But there’s no reason this has to be the final outcome.
Years ago, I wrote that agile software should behave like an immortal jellyfish, capable of continuously adapting rather than gradually succumbing to obsolescence and software rot.
I still believe that. A reliable foundation shouldn’t be frozen in time; it should be capable of evolving while preserving the confidence of the people who depend upon it.
Linux has demonstrated that principle repeatedly, from its early struggles to coordinate a growing development community, through its accommodation of new programming languages, to its current attempts to manage the flood of AI-assisted contributions.
Its history suggests that the solution to a problem of scale is often not simply more effort, but better architecture and better tools.
The little M-VAVE synthesizer presents the opposite side of the equation.
There’s something wonderfully human about a community of musicians and hackers discovering that a cheap instrument can become whatever they can persuade its hardware to do. The participants aren’t necessarily interested in creating a commercially viable product or maintaining an enterprise software release. They’re experimenting, learning from each other, and enjoying the creative possibilities of a device that turns out to be much more capable than its original specifications suggested.
I would hate for the software industry’s legitimate concerns about AI-generated slop to cause us to lose sight of that opportunity.
And I would equally hate for our enthusiasm about suddenly inexpensive software generation to cause us to abandon the hard-won engineering practices that make modern computing dependable.
The two positions aren’t incompatible.
In fact, bringing them together may be one of the more consequential opportunities in software development today.
The FM-1 community reminds us what becomes possible when the barriers to creation fall. The Linux community reminds us what it takes to maintain something worth depending upon. And the work we’re undertaking at Opreto is increasingly concerned with how to make those two worlds coexist productively.
That’s what I’ve always meant by Optimal Velocity: not merely making progress faster, but making progress that improves our capacity to continue making progress.
We’ve spent decades building ladders to bridge software capability gaps. Now that people can jump, perhaps we ought to be building jet boots instead.
The core should be boring. The edges should be wild.
I suspect the most interesting software of the next decade will emerge from getting that relationship right.