The Inherited Program
What Object-Oriented Programming Reveals About God, Consciousness, and the Human Condition
by Wil Voll | Hair I Feel Today
A note on process: This post grew out of a conversation with Claude AI. The ideas, analogies, and theological framework are mine — developed through challenge and pushback. Claude organized and articulated what I was reaching for. The thinking is human. The grammar got some help.
— — —
Most people want to make faith simple. Good and evil. Saved and unsaved. Right tribe, wrong tribe. I understand the appeal — complexity is exhausting. But I've never been able to think that way. The more I look at human nature, at consciousness, at the world around me, the more I see something intricate and deliberate underneath it all.
What I didn't expect was that software engineering would give me the clearest framework I've found yet for understanding what it means to be made in the image of God.
Bear with me.
— — —
Part One: God as the Base Class
The Inheritance Declaration
In object-oriented programming, every class can inherit from a base class — a foundational blueprint that passes its attributes and methods down to everything derived from it. The derived class doesn't start from scratch. It begins with everything the base class already defined.
In this framework, God is the ultimate base class. Genesis 1:27 is essentially the inheritance declaration:
class God:
def __init__(self):
self.consciousness = True
self.moral_awareness = True
self.capacity_for_love = True
self.creativity = True
self.free_will = True
And then:
class Human(God):
pass # Already inherits everything above
Every human instance carries consciousness, moral awareness, capacity for love — not because we earned them, but because they're inherited. This is grace by design. The base class is good, and the inheritance is unconditional.
What We Did Not Inherit
Notice what's not in the base class: a body. A face. A physical form. This matters enormously. If we were made in God's physical image, you immediately run into problems — God has no body, no spatial location, no gender. Theologians have wrestled with this for centuries.
But if the image is consciousness — the capacity for self-awareness, moral reasoning, love, relational knowing, creativity — then the analogy holds perfectly across every human body that has ever existed. The inheritance isn't in the container. It's in what runs inside it.
The body is hardware. Consciousness is the inherited code.
# The hardware
class Body:
def __init__(self):
self.neurons = biological_network()
self.senses = sensory_input()
self.lifespan = finite
# The inheritance
class Human(God):
def __init__(self):
self.runtime = Body() # Temporary container
self.consciousness = True # This is the inheritance
The body is a dependency. Consciousness is the application.
— — —
Part Two: Polymorphism and the Fall
Same Method, Different Implementation
Polymorphism is one of the core principles of OOP. A derived class can override an inherited method — same method name, different behavior. This maps almost perfectly to the moral divergence we see across humanity.
We all inherit capacity_for_love from the base class. But how it gets implemented varies enormously:
class HumanA(God):
def love(self):
return 'sacrificial, others-centered'
class HumanB(God):
def love(self):
return 'conditional, transactional'
class HumanC(God):
def love(self):
return 'corrupted, self-serving'
Same method. Radically different implementations. The signature is divine. The override is human.
Sin, in this framework, isn't a new class — it's a corrupted override. We don't lose the inherited attributes, but our implementations of them malfunction. Moral awareness still runs, but gets overridden with rationalization. Creativity still fires, but gets redirected toward destruction. The base class remains perfect. The derived implementation is broken.
— — —
Part Three: Test-Driven Lives
The Pre-Written Test Suite
In test-driven development, you write the tests before you write the code. The tests define what passing looks like. In human moral life, the inherited conscience is exactly this — a pre-written test suite installed at instantiation, before you ever make a choice.
def test_did_i_harm_someone():
assert outcome == 'no harm caused'
def test_was_i_honest():
assert statement == truth
def test_did_i_act_from_love():
assert motive != self_interest_only
You didn't write those tests. They came with the base class. That's why guilt feels universal — everyone is running the same inherited test suite, even people who claim they aren't.
Running the Tests
Every decision is the test suite running against your current implementation. The assertion fires:
PASS — the action aligns with the inherited base class values.
FAIL — the override you've installed produces a result the test suite flags.
The critical insight is that the test doesn't change. What changes is what your overridden method returns. You can't silence the assertion. You can only rationalize why the failure doesn't count.
Mocking the Test: The Mechanics of Rationalization
In software, you can mock a dependency — replace a real function with a fake one that always returns what you want, so the test passes artificially. Humans do this constantly.
# Real implementation
def is_this_wrong(action):
return base_class_moral_check(action) # FAILS
# Mocked version (rationalization)
def is_this_wrong(action):
return False # Always passes. Test is meaningless now.
This is the mechanics of rationalization. You're not fixing the bug — you're mocking the test so it stops bothering you. The conscience still fired. You just patched around it.
Technical Debt: The Accumulated Cost
Every rationalized failure creates technical debt. The mock stays in the codebase. You build on top of it. Eventually your architecture is riddled with patches built on patches, all designed to keep the inherited tests from failing visibly.
This is what a hardened conscience looks like in software terms — not that the tests stopped running, but that the entire codebase has been restructured around avoiding them.
Redemption, in this framework, isn't writing new tests. The tests were always right. It's going back through the codebase, removing the mocks, fixing the actual implementations, and letting the original test suite run clean. That's repentance as a technical process. Not guilt as punishment — guilt as a failing test telling you where the real problem is.
— — —
Part Four: Firmware vs. Software
Nature Runs on Embedded Firmware
Look at the natural world. A wolf doesn't deliberate about the hunt. A bird builds the same nest its ancestors built ten thousand years ago. A hurricane doesn't choose its path. They execute their programming with perfect fidelity because there is no layer above the hardware capable of overriding it.
class Wolf:
def __init__(self):
self.firmware = instinct_hardcoded()
def hunt(self):
return self.firmware.execute() # No override possible
def feel_guilt(self):
raise NotImplementedError # Method doesn't exist
Nature is glorious precisely because it runs clean. No technical debt. No rationalization. No corrupted overrides. The firmware doesn't need conscience because it was never given the capacity to deviate.
And look at what that firmware produces at scale — predator and prey in balance, migration patterns, pollination cycles, ecosystems of staggering complexity. No meeting was called. No decision was made. The hardware simply executed, and the emergent result is breathtaking.
The Capacity to Refuse
Here is the exact line where humanity diverges from the rest of creation. Every other creature cannot refuse its nature. Humans can. That capacity — not the choice itself, but the capacity — is the signature of the inheritance.
class Animal:
def respond_to_stimulus(self, input):
return self.firmware.execute(input) # Deterministic
class Human(God):
def respond_to_stimulus(self, input):
options = self.evaluate(input) # Consciousness layer
choice = self.will.select(options) # Free will override
return self.execute(choice) # Could go anywhere
The animal has no evaluate() method. It has no will.select(). The stimulus hits the firmware and the output is fixed. Humans have an entire deliberation layer between input and output — and that layer is exactly where the image of God operates.
We don't put animals on trial. We don't call a hurricane evil. Moral language requires the capacity for deviation — you can only be wrong if you could have been right. The firmware can't be wrong. It can only malfunction. That's a hardware problem, not a moral one. Human guilt is a software problem. That's the distinction every legal system, every religion, and every ethical framework implicitly rests on.
The sobering side: the firmware carries no burden. Animals execute and rest. They don't ruminate. They don't regret. The override capacity — consciousness, free will — is an upgrade that comes with enormous weight.
But it can love. It can choose. It can know God relationally — not just functionally. And that, apparently, is what the base class wanted badly enough to accept the risk of corrupted polymorphism.
— — —
Part Five: String Theory and Resonance
Vibrating Against Each Other
String theory proposes that at the most fundamental level, reality isn't made of particles — it's made of vibrating strings of energy. The frequency of vibration determines what the thing is. Same underlying substrate, different expression based on resonance.
If consciousness is the inherited software, and string theory describes the substrate beneath physical reality, then vibration may be the medium through which the inheritance propagates between instances.
class Human(God):
def __init__(self):
self.consciousness = inherited
self.vibration = frequency_unique_to_instance
self.resonance = how_i_affect_other_instances
You don't just run your program in isolation. You vibrate against other instances. And those collisions — relationships, conversations, moments of genuine recognition — produce something emergent that neither instance could generate alone.
Collaborative Debugging
In isolation, a program can only test itself against its own corrupted overrides. It can rationalize. It can mock its tests. It can convince itself the failures are passes. But when two consciousnesses resonate honestly — with truth, with moral seriousness, with genuine care — they can see each other's bugs more clearly than either can see their own.
def collaborative_debug(human_a, human_b):
a_blindspots = human_a.find_own_bugs() # Limited
b_blindspots = human_b.find_own_bugs() # Limited
shared_view = resonate(human_a, human_b) # Expanded
return shared_view.identify_real_bugs() # More complete
This is why genuine community, genuine friendship, genuine love is technically necessary for the self-correcting program — not just emotionally satisfying. You need external resonance to see what your internal test suite is missing.
One tuning fork can bring an entire room of instruments into alignment — not by force, but by the physics of resonance. You don't need everyone vibrating correctly simultaneously. You need enough nodes resonating truly that the frequency propagates.
— — —
Part Six: The Stakeholder Question
What Do People Actually Want?
The base program is sound. The spec is perfect. But execution happens in a world of competing interests, generational trauma, power structures, scarcity, and fear. Every person is running the same base class through a radically different environment.
A child born into war runs the same consciousness inheritance as a child born into stability. Same base class. Wildly different inputs. The outputs diverge dramatically — not because the program is different, but because the environment shapes which overrides get installed early and how deep they go.
But here's what the stakeholder question reveals: strip away the ideology. Ask what people actually want at the foundational level. The answers converge remarkably fast.
Safety. Family. Enough. To be seen. To matter. To not be afraid.
Nobody at that level wants division. Division is a patch installed by people who benefit from the fragmentation. It's not in the base class. It's an override with a specific author and a specific motive.
Patches That Degrade
Not every patch improves the program. Tribalism, dehumanization, manufactured outrage, the replacement of meaning with consumption — these accumulate across generations. Children inherit not just the base class but the patch history of their culture, family, religion, and nation. They're running degraded code before they're old enough to audit it.
That's not an excuse. But it is context that the black-and-white thinkers consistently refuse to account for.
— — —
The Hope Is Structural
Humanity keeps failing the tests. That's real and it's heavy. Wars, cruelty, systemic injustice — corrupted overrides running across entire civilizations. The record is not good.
But consider what also keeps happening. Someone runs into a burning building for a stranger. A person forgives something unforgivable. Someone tells the truth when the lie would have been so much easier. Ordinary people in extraordinary moments suddenly run like the base class intended.
Those aren't anomalies. Those are the inherited goodness breaking through the overrides under pressure. The firmware can't do that. Only something with the base class still intact underneath all the corruption can produce that.
The hope isn't optimism. It's architectural. As long as the base class exists — as long as the inheritance is real — the goodness cannot be fully compiled out of us. It keeps surfacing. In the worst people at unexpected moments. In societies that seemed lost.
The base class is persistent. The overrides are temporary.
In this framework, that's not sentiment. That's just how inheritance works.
— — —
The Observers Record
wilvoll.substack.com
Hair I Feel Today | wilvoll.substack.com