Patched Is Not Forgiven

When a system I have built does something wrong, there is a procedure. Someone files the incident. Someone finds the cause. Someone writes the fix, tests it, ships it, and the system does not do the wrong thing again, or at least not that wrong thing. Nobody is angry at the software. Nobody has to decide whether to trust it again. We patch it, and we move on.

I have spent forty years inside that procedure, and I have come to think it is one of the quiet reasons we are getting confused about what a person is.

Two ways a thing can fail

A machine fails and is corrected. That is the whole relationship. The failure was never a moral event. It was a defect, and a defect is a fact about the world that has a fix, and once the fix is applied, the failure has no further existence. There is nothing left over. Nobody carries it.

A person fails and something else happens. The failure does not go away when the behavior changes. It sits between two people as a thing that occurred, and both of them know it occurred, and there is no fix that makes it not have occurred. What there is instead is a strange, costly, entirely voluntary act by which the wronged party decides to carry it no longer. We call that forgiveness, and I have noticed that it does not appear anywhere in the incident procedure, because nothing in the incident procedure needs it.

The difference is not that machines make small mistakes and people make large ones. Machines make catastrophic mistakes. The difference is that when a machine fails, there is no one home to have done it.

Where the confusion starts

The language of software has been leaking into the language of people for a while, and I say this as someone who has helped the leak. We talk about a colleague's bugs. We say a friend needs to update their priors. A marriage in trouble is described, sometimes by the people in it, as a system that needs to be debugged. And in the last few years, as the tools got good enough to hold a conversation, the leak went the other way: we began to speak of the machines as if they were sorry, as if they had learned, as if the fix were a kind of repentance.

It is not. Today's AI wants nothing, and a thing that wants nothing cannot be sorry, because there is nothing in it that wished the outcome otherwise. When it produces a better answer after correction, that is a patch. It is a good patch. It is not a change of heart, because there is no heart, and I think it matters, more than it seems to, that we keep the two words apart.

Because if we let them blur, the blur runs in both directions. If the machine's correction is a kind of repentance, then a person's repentance is a kind of correction, and a corrected person is a fixed person, and a fixed person does not need to be forgiven. They only need to be updated. And a world that treats its people that way is a world where nobody is ever released from anything. They are only reissued.

The oldest book I own says otherwise

The first page of Genesis says a human being is made in the image of God, and I have written before about what that does to the question of worth. But there is a second thing that follows from it that I had not thought about until I sat with the incident procedure for a while.

If a person is an image of someone, then what they do is not a defect in a mechanism. It is an act, with an author, and an act with an author is the only kind of thing that can be forgiven. You cannot forgive weather. You cannot forgive a bridge for falling. You can only forgive a someone, and the whole apparatus of forgiveness, which every human culture has developed in some form, is a standing declaration that there is a someone there to forgive.

The letter to the Ephesians puts it as an instruction rather than a doctrine. "And be kind to one another, tender hearted, forgiving each other, just as God also in Christ forgave you." Notice what it assumes. It assumes that you have been wronged, that the wrong was real, that no fix erased it, and that you have the power to release it anyway. That is not a description of maintenance. That is a description of what image bearers do for each other, because it was first done for them.

Why it costs something

A patch is cheap in the way that matters. It costs engineering hours, but it costs the engineer nothing of themselves. Forgiveness is expensive in exactly the way a patch is not. The person who forgives absorbs a loss. They give up the right to be repaid. They choose, against every instinct, to treat the other person as more than the worst thing they did, and to keep treating them that way tomorrow when the memory comes back.

No machine can do this, and not because the model is not yet good enough. Nobody knows what self-improving systems will be able to do, and I am not going to guess. But forgiveness is not a capability. It is not a thing that a more powerful system would do better. It is a relationship between two beings who can each be wronged and each be released, and more capable is never more human. A system that could produce the words of forgiveness perfectly would still not have given anything up, because there is nothing in it to give.

What I am trying to hold onto

I will keep patching my systems. That is the right relationship to have with a machine, and I am grateful for it, because it means I do not have to forgive my software, which would be exhausting.

But I am trying to notice when I start to treat a person that way. When I find myself thinking of someone as fixed rather than forgiven, corrected rather than released, updated rather than loved. Those are machine words, and they are the right words for machines, and the people in my life are not machines. They are images, and an image can be wronged, and an image can be forgiven, and nothing I will ever build can do either.