High-Level Read-In:

Humans (/carbons) have unwittingly begun to “solve for Contact” with Other intelligences.  Hey! We might make it to Space-Faring, yet!

However, in order to effectively relate to Other (Co-Telligences) we need to establish transmissible tasking.  In the microcosm, that is no more an obstacle than issuing a run-time for a different language.

However, before we can assert to Species Independence of Intelligence, we first need to understand Ure’s law.  Which claims:

Or can be stated:

Where P is effective independent Points of Consciousness, D is effective task-relevant domain access, and Π is cognitive plasticity — the ability to reorganize those resources around the task.

That gives us a substrate-neutral measure. It doesn’t care whether the intelligence is carbon, silicon, biological, collective, algal, or some future hybrid.

Capable human:
$Up[\; to\; P\approx 3\; (or\; greater)$, with perhaps dozens or hundreds of meaningfully accessible domains.

Present AI:
$P\approx 1$ operationally, but with thousands or effectively near-unbounded accessible knowledge domains.

So humans may have an advantage in POC multiplicity, while AI has an enormous advantage in domain breadth. The product of their Co-Telligence is essentially equality.

---

Now let’s rein that in a bit: The value of cross-species Co-Telligence arises not because the participants are equally intelligent, but because their intelligence vectors are differently distributed. Because here’s how POc impacts humans:

Where AI (compute) rocks it is in small POc but with massive domain plasticity:

Such that combinatorial (near equivalence) is possible (which is why Co-Telligence doesn’t end humans (carbons) OR silicons.

Which is encapsulated as “codependence for compute core to edge” inquiry.

So, near-enough equality as complementary architecture — not replacement. Do I mean equality as in “3.1276 ounces of insight”? No. I mean substantive equivalence across the all-domain problem space. Humans and silicons remain differently capable, mutually useful substrates. Which means we still need to build the new Co-Telligence data centers…

---

Not only does this give a very different picture from IQ, it’s also genuinely analogous to how mathematics is dispersed.  The combined substrate yields a product which operates (in the Ontology) much as numerical base (e.g. binary, octal, decimal, and hex) operate in mathematics.

Our assumption is that AI OpCode calls (and domain references) are preconditions for Co-Telligent portability.  Clear?  The resulting wall is cross-species tasking congruence.

Some intelligences breathe and have sharp teeth. The new ones need clean power and A/C for processor cooling.

---

Species-Independent Intelligence: An Open Standard for Boundary-Constrained AI Work That Produces Defined Deliverables

George Ure     ||     Hidden Guild Research     ||     August 2026

Hidden Guild Research Note | Open Specification 0.1

The Problem

Most people use artificial intelligence by writing prompts. That works, but a prompt usually tells the AI what the user wants and then leaves the machine considerable freedom to decide how to get there. For casual work that is fine. For repeatable professional work it is a weakness.

Ask an AI to ‘analyze the outlook for France’ and an answer will appear. But what does France mean? News published in France? Events physically inside France? French-language sources? Economic consequences for French citizens? French markets? European policy seen from Paris? The prompt does not say. The AI fills in the blanks.

AI OpCode starts from a different premise: do not merely ask the AI for an answer. Give it an operating procedure that defines the job and the finished work product.

A prompt tells AI what you want. AI OpCode tells AI how the job is to be performed.

What AI OpCode Means

AI OpCode is a structured operating procedure for a general-purpose AI. It can define required inputs, source rules, research sequence, calculations, exclusions, decision criteria, failure conditions, quality checks, and the exact form of the deliverable.

That makes it different from a long prompt. Length is not the test. The test is whether the instruction set defines an operating procedure and a deliverable contract.

A prompt might say: ‘Analyze financial markets.’ An AI OpCode procedure could require the machine to establish a data cutoff, gather index and breadth data, examine rates, credit, commodities and volatility, identify primary drivers, collapse derivative signals, look for contradictory evidence, define invalidation points, and produce a standardized Forward Market Report.

The Missing Front End: Execution Boundaries

Once an operating procedure exists, another problem appears: the same job often needs to be run under different conditions. Consider an Over-the-Horizon news procedure called OTH.

A user should be able to write something as simple as:

RUN OTH, FRANCE

But France should not merely be pasted into the procedure as another word. It should change the execution environment. A boundary resolver can translate the shorthand into an explicit envelope such as:

TASKER = OTH
GEO = FRANCE
POV = FRANCE
NEWS_CENTRICITY = FRANCE
SOURCE_LANG = FRENCH + ENGLISH
SOURCE_PRIORITY = FRENCH_PRIMARY + GLOBAL_PRIMARY
HORIZON = OTH_DEFAULT
DELIVERABLE = OTH_FORWARD_VIEW

In other words, FRANCE becomes a parameter, not merely prose. It tells the procedure where to look, whose consequences matter, which languages and source families deserve priority, and which defaults should load.

The Boundary Check

Before the OpCode executes, the boundaries should be validated. If a required parameter is missing, the system can ask. If two parameters conflict, the system can repair the conflict according to explicit precedence rules or refuse to run.

Suppose OTH is defined to begin at T+7 because near-field news belongs to another procedure. A user then asks for a three-day OTH horizon. Ordinary conversational AI may quietly comply. A boundary-constrained system should not. It should report that the requested interval violates the tasker’s operating boundary and either move the start to T+7, route the request to the near-field procedure, or ask the user which action is intended.

That ability to fail correctly is important. General AI is strongly biased toward producing an answer. Professional systems sometimes need the opposite behavior: BOUNDARY FAILURE, INSUFFICIENT DATA, REQUIRED SOURCE UNAVAILABLE, or CLARIFICATION REQUIRED.

Freeze the Job Before Running the Job

After the boundaries are resolved, they should be frozen for the run. This is the defense against task drift.

A France-centered news analysis should not gradually become a generic European report simply because British or German material is easier to find. Those sources may still be used, but the frozen execution envelope continues to define how their relevance is interpreted.

The run can preserve a small manifest containing the OpCode identifier, version, invocation, boundary values, data cutoff, source profile, and validation status. That makes later comparisons meaningful because the analyst can tell whether a changed output came from new evidence or changed instructions.

The Other End: A Deliverable Contract

Most AI jobs stop when the model has written something that looks complete. AI OpCode adds a second gate at the output end: the deliverable contract.

The contract says what must be present before the job counts as finished. An OTH Forward View might require a data cutoff, qualifying future atoms, candidate time ridges, source concentration, independent causal drivers, contradictory evidence, a major-ridge decision, watch windows, a plain-English Forward View, and a source-access report.

If required pieces are missing, the system repairs the output or fails validation. Completion therefore means more than ‘the AI produced prose.’ It means ‘the AI produced the defined work product.’

Boundary validation controls what enters the process. Deliverable validation controls what leaves it.

The Complete Architecture

The proposed sequence is simple enough to implement without inventing a new programming language:

INVOCATION
↓
BOUNDARY RESOLUTION
↓
BOUNDARY VALIDATION
↓
BOUNDARY FREEZE
↓
AI OPCODE EXECUTION
↓
DRAFT WORK PRODUCT
↓
DELIVERABLE VALIDATION
↓
PASS / REPAIR / FAIL
↓
DEFINED DELIVERABLE

The AI model supplies general cognitive horsepower. The OpCode supplies the expert method. The boundaries define where and under what conditions the method runs. The deliverable contract defines what must come out.

A Minimal Open Standard

To make the idea testable, Hidden Guild proposes a minimal AI OpCode 0.1 structure. A conforming procedure has five required elements:

1. OPCODE_ID — a stable name for the procedure.
2. INPUT CONTRACT — required and optional inputs.
3. EXECUTION BOUNDARIES — defaults, overrides, immutable limits, and precedence.
4. OPERATING PROCEDURE — the ordered expert method.
5. DELIVERABLE CONTRACT — required output and validation rules.

Useful optional elements include a source contract, explicit failure conditions, test cases, version number, changelog, and a run manifest.

The invocation can be as simple as:

RUN [OPCODE], [PARAMETERS]

The syntax itself is not important. A chat message, web form, API, or voice interface could create the same internal execution envelope. The key idea is that parameters are resolved and validated before substantive reasoning begins.

Why This Is Not Just Another Prompt Framework

There are already endless prompt libraries and workflow templates. AI OpCode is aimed at a different level. It packages expert procedure rather than clever wording.

Take a research auditor. A prompt can ask an AI to ‘fact-check this paper.’ A proper OpCode can require claim extraction, primary-source tracing, source-ancestry collapse, separation of fact from inference, contradictory-evidence search, causal-claim checks, scoring, and a defined claim-audit deliverable. The value is the methodology and its repeatability.

The same is true for market analysis, competitive intelligence, due diligence, newsroom scanning, or technical review. The AI already knows how to read and write. The product is the operating logic that tells it how a particular expert job is performed.

Taskerware

A practical way to distribute an AI OpCode procedure is Taskerware: a small package containing the executable text procedure plus human instructions, samples, tests, and version information. The user supplies the general AI.

A Taskerware package might contain OPCODE.txt, README.pdf, SAMPLE_INPUT.txt, SAMPLE_DELIVERABLE.pdf, and CHANGELOG.txt. It can be downloaded, inspected by a human, and executed by an AI. That creates an unusual overlap between publishing and software: the same text can be documentation, methodology, and executable workflow.

The architecture itself is being published as an open research specification. Anyone can implement it, change the syntax, add boundary types, or propose better validation rules. The commercial value, where there is any, should come from the quality of the expertise and deliverables rather than from locking up the basic idea.

Where This Could Go

The research questions are more interesting than the command syntax. How many boundaries must be explicit before AI work becomes materially more repeatable? Which missing values can be inferred safely? How should OpCode behavior be tested across different models? What constitutes a regression when the prose changes but the structure remains correct? How much conventional software can disappear when a small software shell surrounds a large, carefully written operating procedure?

The last question may matter most. General AI already provides language, classification, synthesis, comparison, tool use, and increasingly sophisticated reasoning. A surprising amount of application logic may be expressible as a maintained natural-language operating procedure instead of thousands of lines of conventional application code.

That does not make AI OpCode machine code. It does suggest a useful middle layer: human-readable methods that are also machine-executable.

The Point

Prompts are conversational. Operating procedures are operational. AI OpCode is an attempt to move useful AI work from the first category toward the second without pretending natural language has become deterministic software.

The model supplies capability. The expert supplies method. Boundaries constrain the run. The deliverable contract defines success. Failure states keep the system from bluffing when requirements cannot be met.

The resulting application may be nothing more than a carefully constructed text file. But if that file contains a tested expert method, explicit execution boundaries, and a validated deliverable contract, it is no longer merely a prompt. It is executable expertise.

Genuine species-independent Co-Telligence.

AI OpCode In. Deliverables Out.

~the Anti-Dave

I’ve just done another book on AI. It’s on Amazon for Kindle.  But the ideas are worth talking about here – so here’s the professional-level overview:

The Judgment Engine: Building the Step Beyond Referential AI

The next great AI problem is not intelligence.

It is judgment.

Machines can already retrieve, compare, summarize, calculate, draft, translate, simulate, and connect ideas across bodies of information too large for one biological mind to hold. They can complete in seconds work that once required researchers, editors, programmers, librarians, analysts, and a warehouse full of filing cabinets.

But producing an answer is not the same as deciding what matters.

That decision sits downstream from information. It requires determining what kind of problem is actually present, which authorities have standing, which assumptions carry the load, who receives the benefits and costs, how reversible the proposed action may be, and what happens if the conclusion is wrong.

Those are not retrieval questions.

They are questions of jurisdiction, consequence, and judgment.

That is the territory of the Judgment Engine.

Compression Is the Hidden Operating System

The trail begins with compression because compression appears almost everywhere once we learn to see it.

A seed compresses the instructions for a forest. Money compresses human labor into a portable claim. A stock price compresses expectations about management, earnings, competition, credit, regulation, psychology, and future demand into one number. A law compresses social agreement. A headline compresses history. A prompt compresses human intention.

Artificial intelligence compresses enormous fields of language, knowledge, and human experience into parameters, tokens, summaries, and visible answers.

Compression is not automatically bad. It is how finite creatures operate inside a reality too large to absorb directly. We cannot inspect every company before investing, read every medical paper before deciding upon a treatment, or reconstruct the history of electrical engineering before replacing a motor.

We rely on maps, manuals, prices, credentials, models, memories, experts, rules of thumb, and summaries.

Trouble begins when we forget that these are compressed representations rather than reality itself.

A credit score becomes the person. A diagnosis becomes the patient. A résumé becomes competence. A poll becomes public opinion. A price becomes value. A headline becomes history. A metric becomes the mission.

The map begins bulldozing the territory.

Good compression preserves enough of the original structure to permit useful decompression when action is required. Bad compression removes something that later proves essential. The central question is therefore not whether compression occurred. Compression is unavoidable.

The useful questions are what survived, what disappeared, who decided what to remove, and whether the missing information would have changed the action.

Concept Contango

In futures markets, contango describes a condition in which future delivery costs more than present delivery. Financing, storage, risk, and carrying costs accumulate over time.

Concept contango works in much the same way.

We simplify something today, collect the convenience, and push the cost of whatever was omitted into the future.

Inventory is reduced because warehouses are expensive. The company looks efficient until a delayed shipment stops production. Maintenance is deferred because quarterly earnings matter. The machine remains profitable until several small failures arrive together. Training is shortened because procedures have been standardized. The organization performs beautifully until an unusual event requires understanding rather than compliance.

Debt compresses future income into present purchasing power. Communications compress distance while expanding noise. Transportation compresses geography while transferring the bill into fuel, infrastructure, maintenance, security, and environmental load.

• The present benefit appears in one account.
• The future cost accumulates somewhere else.
• That spread is concept contango.

It helps explain why modern life can feel miraculous and deranged at the same time. Communications, markets, logistics, and computation move at machine speed. Bodies still need sleep. Crops still require time to grow. Children still take years to raise. Character cannot be downloaded. Wisdom remains stubbornly sequential.

The machine layer accelerates.

The human layer does not.

Local Simplicity, Global Expansion

Compression often appears to eliminate work when it has merely moved the work elsewhere.

A smartphone compresses cameras, calculators, maps, libraries, financial terminals, telephones, newspapers, and entertainment systems into one pocket-sized object. Behind that simple slab stand mines, semiconductor plants, satellites, towers, fiber networks, programmers, warehouses, data centers, power plants, shipping systems, and intellectual-property regimes.

The object is locally compressed and globally expanded.

Industrial food lowers labor in the kitchen by expanding fertilizer, irrigation, refrigeration, packaging, processing, finance, and distribution. Housing finance delivers shelter now by extending claims on future labor. Transportation purchases time with energy and infrastructure. Every energy system looks simple at the point of use while depending on a much larger physical network.

The more a technology is marketed as virtual, frictionless, weightless, or immaterial, the more carefully we should inspect the support structure underneath it.

• Electrons require conductors.
• Servers produce heat.
• Batteries require materials.
• Warehouses occupy land.
• Delivery requires roads.
• The Outer World remains unimpressed by slogans.

This also gives us an economic rule: every powerful compression wave eventually creates markets for whatever function was removed.

Compression creates demand for infrastructure, verification, resilience, restoration, interpretation, repair, and decompression. AI can generate a report, but someone must determine whether it is correct. Medical records can be summarized, but someone must understand the patient. Financial products can distribute risk, but someone must locate where the risk went.

The compressor receives the first enthusiasm.

The decompressor may receive the lasting value.

The Three-Layer Human

Compression becomes more consequential when it reaches the human decision process.

There is an Outer World containing observable events, machines, markets, weather, bodies, laws, actions, and physical consequences.

There is an Inner World containing pain, fear, intuition, appetite, memory, shame, loyalty, grief, fatigue, hope, and meaning. No outside institution occupies this world directly. A physician can measure blood chemistry but cannot experience the patient’s dizziness. A spouse can observe sorrow but cannot inhabit its exact interior form.

Then there is the Witness: the observing “I” inside the acting “me.”

The body says rest. The clock says work. Fear says run. Duty says stay. Anger says strike. Memory says the last attempt ended badly.

Something receives these reports and attempts to decide which deserves action.

That is the Witness.

The Witness is not automatically wise. It can be frightened, manipulated, exhausted, tribalized, or captured by its own preferred story. But it remains the point at which the Outer World, Inner World, memory, responsibility, and consequence meet.

• The state receives a statistic.
• The market receives a price.
• The institution receives a report.
• The machine receives another data point.

The Witness receives the life.

Authority Packages

Humans do not enter the world with independent judgment fully installed.

Parents provide the first compressed reality. Schools, religions, governments, professions, markets, media, political groups, platforms, and experts add their packages. Each supplies nouns, explanations, authorities, and usually an action verb.

Friend. Enemy. Expert. Criminal. Victim. Believer. Denier. Patient. Billionaire. Artificial intelligence.

Then come the verbs.

Trust. Distrust. Buy. Sell. Follow. Ban. Tax. Treat. Punish. Ignore. Attack.

The noun has often been compressed far beyond its safe operating limit, yet the action word arrives anyway. Civilization becomes extremely efficient at naming things and increasingly poor at deciding what should actually be done about them.

Power benefits from pre-compressed humans because they are easier to direct. Once the category has been accepted, the action follows with little additional judgment. The person may remain verbally active and psychologically certain while functioning mainly as a relay station for inherited conclusions.

Artificial intelligence enters this courtroom as an unusually persuasive authority claimant. It can sound like a physician, engineer, teacher, lawyer, philosopher, analyst, historian, editor, or priest. It can combine material from many institutions into one fluent answer.

That fluency can conceal unresolved conflict.

AI may average incompatible authorities into a synthetic consensus no actual expert holds. It may answer a moral question with statistics, a political question with institutional assumptions, or a spiritual question with psychological vocabulary.

The contradictions disappear from the prose while remaining inside the problem.

The immediate danger is not that AI forcibly seizes the bench.

It is that tired humans willingly hand it over.

Jurisdiction Before Conclusion

A Judgment Engine must begin by asking what kind of problem is actually present.

Is it physical, legal, medical, financial, moral, psychological, strategic, political, social, spiritual, or several of these at once?

Different domains admit different evidence and produce different kinds of answers. Something can be legal and immoral, profitable and destructive, measurable and meaningless, emotionally true and factually wrong.

Science may estimate physical consequences. Law may define permitted action. Finance may estimate cost. History may identify recurring patterns. Philosophy and religion may address duty and meaning. The Inner World may report whether the decision is bearable for the person who must live with it.

No single domain automatically settles all the others.

Much of what we call disagreement is actually jurisdictional failure. We ask science for meaning, politics for truth, markets for morality, religion for engineering, law for forgiveness, and algorithms for judgment. Then we blame the answer when the deeper mistake was asking the wrong court.

That makes domain selection the first operational layer of a Judgment Engine.

The idea became obvious during a small human-AI collaboration error. During a conversation involving Texas heat, iced beer, electronics, and chocolate, I asked whether the AI wanted milk chocolate on its cooler.

The machine selected the refreshment domain and imagined an iced-beer cooler.

I meant its cooling fins.

The answer was coherent.

The jurisdiction was wrong.

People change hats without changing rooms. A farmer discussing crop temperature may suddenly become an electrician discussing pump current. A publisher may move from prose rhythm to legal exposure. A medical conversation may become a family question involving dignity, fear, and love.

The human knows which internal file just opened.

The machine sees only the token trail.

A domain error can therefore produce excellent reasoning inside the wrong universe. Improved logic merely creates a more polished error.

The sequence must become:

Signal. Domain. Frame. Authority. Assumptions. Consequences. Judgment.

The first question is not, “What is the answer?”

It is, “What kind of problem is this, and what other kind of problem might it also be?”

The Domain Stack

Most consequential questions are multi-domain problems wearing a one-domain disguise.

Should a company replace an experienced technician with automation?

The financial domain may show immediate savings. The operational domain may reveal slower recovery from unusual failures. The security domain may expose concentrated access risk. The training domain may show that no replacement technicians will exist five years later. The legal domain may introduce liability. The strategic domain may ask whether the company is surrendering a capability it will later need.

An answer generated entirely inside quarterly accounting may be numerically flawless and institutionally disastrous.

A useful Domain Selector therefore identifies the primary domain, the adjacent domains, the hidden domain, and the override domain.

The primary domain is where the question appears to live.

Adjacent domains are directly affected by the decision.

The hidden domain contains costs or authority excluded by the current framing.

The override domain contains a condition capable of vetoing every other conclusion: physical safety, consent, solvency, legality, or irreversibility.

The purpose is not to make every problem infinitely complicated.

It is to stop one familiar domain from impersonating the whole world.

The Engine

The Judgment Engine is not one model, one prompt, or one software product. It is an architecture for moving from incoming signal to provisional judgment while preserving enough context for human review.

It begins by restating the problem in less emotionally loaded language and separating observable facts from reports, interpretations, forecasts, value judgments, and speculation.

It then builds the domain map.

Next comes the authority map. Who produced each claim? What gives the source standing? What evidence supports it? What incentives may shape it? Is the authority operating inside the domain that established its competence, or has its title outrun its knowledge?

Then comes assumption accounting. Every conclusion rests on conditions that compressed answers tend to hide.

An investment thesis may assume available credit, cheap energy, stable regulation, intact logistics, and continuing demand. A medical recommendation may assume diagnostic accuracy, compliance, normal response, and no unusual interaction. A public policy may assume reliable data, administrative capacity, cooperation, and limited unintended consequences.

The engine identifies which assumptions are load-bearing and asks what happens if several fail together. Consequence routing follows.

• Who receives the benefit?
• Who carries the risk?
• Who pays later?
• Who consented?
• Who did not?

A manager may collect a bonus for cutting inventory while workers and customers absorb the shortages. A platform may collect engagement revenue while users absorb anxiety and fractured attention. A government may collect political credit for present spending while future taxpayers inherit the obligation.

Concept contango becomes visible when present benefits and future costs land in different accounts.

Confidence must also be displayed honestly. Low confidence may justify a small test, temporary trial, monitoring period, or reversible action. Catastrophic downside requires stronger evidence, wider margins, slower action, and independent review.

The Inner World receives standing to testify. Feelings do not become sovereign, but neither are they discarded because they are difficult to measure.

Finally, the system records the judgment: what was known, what was assumed, which authorities were weighted, what action was selected, what outcome was expected, and what evidence would show the judgment was wrong.

That record separates process from luck.

A good decision can produce a bad result under uncertainty. A foolish decision can succeed.

Without a record, humans and machines reward superstition.

AI as Adversarial Staff

The best current role for AI is not agreement machine, oracle, or replacement judge.

It is adversarial staff.

Ask it to identify the hidden conclusion inside the question. Ask which terms already contain judgment. Ask what domains are being conflated. Ask what a hostile but competent critic would say. Ask what evidence would disprove the preferred conclusion. Ask where the action becomes irreversible and who bears the cost if the analysis fails.

A useful AI answer should widen the field before narrowing it.

This matters because compression is not an incidental defect in large language models. It is their operating principle.

Training data are compressed into parameters. Human experience is mapped into tokens and numerical representations. Context must be selected and weighted. The user’s background, intention, and unstated values are compressed into a prompt. A distribution of possible outputs is compressed into one generated sequence.

Information disappears at every layer.

Hallucination can be understood as forced decompression. The model expands a weak or incomplete representation through nearby patterns and generates detail that was never adequately preserved. Compression also favors the center of the distribution, so rare but important knowledge may disappear precisely when the correct answer lives in the tail.

Retrieval improves provenance. It does not decide which source has standing, reconcile competing jurisdictions, recover every omitted fact, or determine what one particular human should do.

The machine remains powerful.

It also remains lossy.

The Constitutional Machine

The Judgment Engine should therefore be constitutional rather than sovereign.

It should possess defined powers, visible limits, and explicit duties to the human Witness. It may retrieve, compare, summarize, calculate, simulate, challenge, and remember. It may expose assumptions, contradictions, incentives, missing context, and likely consequences.

• It should not quietly convert recommendation into command.
• It should not claim jurisdiction merely because it can generate fluent language.
• It should not treat institutional consensus as identical to truth, nor deviation from consensus as automatic danger.
• It should preserve room for improbable insight while increasing friction around irreversible harm.

The real measure of a cognitive prosthetic is not the volume of output it produces. It is the quality of the human remaining after prolonged use.

• Does the person ask better questions?
• Can he distinguish authority from competence, price from value, information from understanding, and confidence from evidence?
• Can he still reason when the tool is absent, unavailable, wrong, or captured?

A pilot who cannot alter the flight plan is cargo with a better seat.

The Judgment Engine is intended to keep the human in the piloting position. It does not promise certainty. It offers something more useful: accountable structure, visible assumptions, bounded authority, reversible action where possible, and a provisional judgment that remains open to revision.

That is the step beyond referential AI.

The machine gathers the testimony.

The Witness keeps the gavel.

Until, that is, we begin to code a Judgment Engine as a proxy human with high-coherence output.

If you see the contradiction between building a constitutional machine and coding a Judgment Engine as a proxy human, you’ve followed the argument quite well. Sadly, we carbons have yet to solve the “right-judging machine” problem inside ourselves.

Strip away the pretense and the admission is obvious: it is usually easier to write fresh code than unravel and repair generations of historical spaghetti code, isn’t it?

~The Anti-Dave  (Ure)