humane computing (noun) The art of designing computer systems such that they can be understood by a single human mind
If no one can understand a system, no one can be responsible for it. If no one is responsible for it, it must not run.
It can be halted at any moment without being destroyed. While halted, a person can see what it is doing, what it just did, and why, then change it and let it continue. A dump of a dead system is not a pause. A log you can only read after the run is over is not a pause.
Every transformation from human-written material to machine instructions keeps a two-way map, instance by instance. That map includes the seeds and settings that shaped the result. Each time the machine writes a piece of code, that piece is tagged to the exact request that wrote it - and you can follow the tag the other way, down to the instructions that ran. A one-way map does not count. A template that blurs many uses into one story does not count. A map rebuilt later from guesses does not count.
Every result can be walked back to the inputs and steps that produced it, and every input forward to its effects. The chain is written down as the step happens. "We could reconstruct it if asked" is not a chain. For learned systems, the record includes the training data, the parameters, and the links between them and each result - as they are used, not as a later report.
People understand systems in layers. The layers are few and used the same way throughout. Whatever slice a person is looking at fits in the handful of things they can keep in mind at once. The maps and chains let a person move between layers while the system is paused without losing their place. If a slice is too large to hold, the system is not finished. Splitting the mess across more files and calling it architecture does not finish it.
Everything the system remembers is named, listable, and readable now. Anything that can change a result without a name is hidden state, whether it sits in a cache, a numerical blob, an unstated prompt, or an unrecorded step. Hidden state is a break in the maps and chains. State you could dump if you attached a debugger is still hidden if a person cannot name and read it in the ordinary pause.
Any saved moment can be restored. Any action that matters can be undone and redone. After a pause and a change, the same live system continues. A fresh run that only resembles the old one does not count. Replay without resume is a lab note. Resume without replay is a creature you cannot take back.
Understanding means working with a running system, not reading a snapshot. A person can ask "what if", change a cause, continue, see a different result, and walk the chain to see why it changed. Live edits update the maps and chains as they happen. If a change leaves the path unwalkable, the system is no longer humane until the path is restored and an owner accepts it again.
The seven properties make responsibility possible. Ownership makes it actual.
A humane system is owned, at all times. A named human has passed the handoff check - paused it, walked it, changed it, continued it - and accepted responsibility for it in their own words. That person, not the system, is responsible for what it does. An AI system can produce work. It cannot be responsible for it.
An owner is not a string in a config file, a team alias, a rotation calendar, or a model's claim that "a human is in the loop". The owner is the person who can still do the check.
Ownership is not a signature on opening day. It holds for as long as the system runs. It lapses when the owner leaves, can no longer pass the handoff check, or the system has changed beyond what they checked. The maps may still be valid after that change. Responsibility is not. The running system is no longer the system that was accepted.
A system with no responsible human is not humane, even if every other property holds.
Three states, and only three:
There is no fourth state called "keep going unsupervised."
The system may not know that it is no longer owned. People leave. Attention fails. The name on file can outlast the person who understood the work. A machine cannot be trusted to notice that vacancy.
So the design default is not clever recovery and not undefined behavior. The default is to wait.
Reality can get in the way - power, hardware, a crashed disk, a physical process that will not freeze. Best effort is not a shrug. It means: refuse new work, keep the last state inspectable, and leave a trail a person can walk when they arrive. "We tried" after the system has already taken the next unowned step does not count.
A system that races on when nobody is responsible is not autonomous. It is unowned.
These are not near-misses. They are misses.
Most computing systems today, including large language models, fail these tests - not only the last one. These systems are irresponsible and inhumane.
Every system that affects human lives needs a responsible human. A civil engineer stamps a bridge. A CFO signs the books. The name means something only because that person understands what they are signing.
That is breaking down. Machine-written code now runs in the world with little review and less understanding, yet people are still treated as responsible for it. Responsibility without understanding is a fiction. A society built on that fiction cannot correct its failures, because no one who owns them can see them.
Only a human can be responsible. An AI system cannot take that seat.
Opacity is not inevitable. Forth, Smalltalk, Oberon, and VPRI's STEPS project showed that a whole computing system can be small enough, and live enough, for one person to halt it, read it, change it, and continue. Opaque systems last because their costs arrive late and fall on people who never chose them. When those costs become visible, people will demand humane systems.
This applies to human and AI builders alike.
A system that cannot be understood by a single human mind cannot have a human responsible for it.
No system should run for which no human is responsible.
humanecomputing.org
Contact: - Dave Goehrig