TL;DR
- Any rule-based system faces an infinite space of possible transformations. Some contradict each other, so no set of instructions can cover them all.
- Every instruction also forbids at least one alternative. So what a system cannot do always matches or exceeds what it can do. That is why conventional programming cannot build general AI: each fix is a new instruction with new prohibitions.
- The proposed alternative is a fractal system. One simple instruction generates independent subsystems whose rules never interfere, so the parent stays simple.
Key Takeaways
- The argument is a purely formal one about instruction-based systems in general, not a claim about the limits of any specific current AI architecture. Its force depends on accepting that general intelligence genuinely requires handling an unbounded, unpredictable space of transformations, not merely a very large finite one.
- Framing prohibitions as compounding faster than capabilities reframes the difficulty of general AI as a structural property of rule-writing itself, rather than a matter of needing more rules, more compute, or more careful engineers. That reframing is what motivates looking outside conventional instruction-based programming altogether.
- The proposed fractal escape route works by preventing instructions in different subsystems from ever having to interact. It buys unbounded behavioural variety without ever writing a global rule that has to reconcile every case, rather than resolving the contradictions the essay identifies.
- The piece functions as the theoretical companion to the site’s separate proposal for a disk-space-driven self-improving AI. The argument here supplies the reason that design uses subsystem generation rather than direct instruction; it is not a demonstration in itself.
Assume a system that uses instructions (rules or sets of rules) to transform inputs into outputs. That is conventional, rule-based programming: every behaviour is an instruction written in advance. A general AI, or artificial general intelligence, has to handle inputs and outputs nobody anticipated. The argument below shows why conventional programming cannot build general AI.
Why Can’t Rule-Based Programming Build General AI?
An infinite number of transformations are possible.
A rule-based system performs only the transformations its instructions allow. So what does each new instruction do to all the others?
Why Does Every Instruction Create a Prohibition?
No instruction, however comprehensive, can incorporate all possible transformations, purely because some of them are mutually contradictory. The instruction “save input A” is mutually incompatible with the instruction “delete input A”, for example.
Because no instruction can be global, every instruction added to the system also adds at least one prohibition. The instruction “do A” forbids the system from not doing A.
In practice, the addition of a new instruction will generally create more than one additional prohibition. “Add 2 to input A”, for example, forbids the system from adding 3 or 4 to input A, as well as deleting or ignoring it, converting it to a different data format, etc.
Why Do More Rules Make the Problem More Complex?
Thus, a system with n instructions will also contain n + x prohibitions, where x is an integer equal to or greater than zero.
This means that the number of things that the system cannot do will always be greater than or equal to the number of things that it can do.
Why Does General AI Require More Than Conventional Instructions?
When dealing with finite and predictable sets of inputs and/or outputs, this is of no concern, since their finite and predictable nature limits the number and nature of the transformations required of the system.
General AI, however, must be able to deal with infinite and unpredictable input and output sets. Therefore, it must retain the capacity to perform all (or close to all) possible transformations.
This means that a general AI cannot be programmed through the establishment of rule-based instructions, since every instruction added to enable it to carry out a particular transformation will forbid it from carrying out one or more others.
To avoid or mitigate the effects of these prohibitions, one or more exceptions must be written, which, being themselves instructions, create new prohibitions of their own.
In other words, the closer programmers approach the levels of complexity required for general AI, the more complex the problem becomes.
What Is the Proposed Alternative to Rule-Based/Conventional Programming?
To avoid this problem, it is necessary to have recourse to iterative or fractal systems, via which an infinitely complex set of subsystems may be created through a simple initial instruction. Under such a system, the initial instruction generates a set of subsystems of potentially infinite variety. While these subsystems have instructions and (therefore) prohibitions of their own, there is no mathematical interference between the instructions and prohibitions of each system.
How Do Fractal Systems Avoid Instructional Interference?
Instructing System 1 to perform transformation A and thereby forbidding it from performing transformation B has no effect on System 2’s ability or inability to perform transformation B. Thus, the parent system retains its initial level of Kolmogorov simplicity. Because it is only ever subject to one instruction (the sub-system generation instruction), the number of prohibitions to which it is subject does not increase.
How Can One Instruction Generate Complex Behaviour?
In theory, using this method, it is possible to create a complex system with just one global prohibition. Our system for evolving a generalising AI from existing technologies shows how this could be done. Its program has a single drive, to occupy more disk space. New skills arise as generated subsystems, not hand-written rules.
Conclusion
Rule-based programming works when the inputs and outputs are finite and predictable. General AI removes that limit, and the formal argument shows what follows. Every instruction forbids something, every exception is another instruction, and the prohibitions grow with the rules. Conventional programming cannot build general AI by adding more of them.
The alternative is to stop writing the behaviour directly. A single instruction that generates independent subsystems keeps the parent system simple, while its subsystems vary without limit. That is the principle behind recursive self-improvement. The system produces and tests its own components instead of waiting for a programmer.
The same argument underlies our self-improving AI agents. They learn new skills from what works in their environment, not from hand-written rules.
FAQs
What is rule-based AI?
Rule-based AI turns inputs into outputs by following instructions written in advance: if this, do that. Every behaviour it has comes from a rule someone wrote. It works well when the possible inputs and outputs are finite and predictable, as in a tax calculator. There, the rules can cover every case.
Why can’t rule-based programming create general AI?
Conventional programming cannot build general AI because every instruction also creates at least one prohibition. A general AI must handle unbounded, unpredictable inputs, so it needs nearly every transformation available. Each rule closes some off. Each exception written to reopen them is a new rule with prohibitions of its own, so complexity grows with every fix.
What are the limitations of rule-based AI?
The limitations of rule-based systems grow with the rules. A system with n instructions carries at least n prohibitions. What it cannot do always matches or exceeds what it can do. That is harmless for narrow, predictable tasks. For open-ended ones, fixes add complexity faster than capability, and the system never covers every case.
What is the difference between rule-based AI and general AI?
Rule-based AI handles a finite, predictable set of inputs and outputs that its programmers anticipated. General AI, or artificial general intelligence, has to handle unbounded and unpredictable inputs and outputs. So it must keep the capacity for nearly every transformation. The first can be written as rules; this argument says the second cannot.
What is a fractal AI system?
A fractal AI system grows complexity from one simple instruction: generate subsystems. Each subsystem has its own instructions and prohibitions, but they never interfere with each other’s. The parent system stays as simple as it started, subject to a single instruction, while the subsystems it produces can vary without limit.
Can general AI be programmed?
Not, this argument holds, by programming general AI one rule at a time. It can instead be set up: a single subsystem-generation instruction lets complex behaviour emerge from independent subsystems. The companion design applies this to a program driven to occupy more disk space. It learns new skills instead of having them written in.
