Core thesis

AI is not automating software evenly, and it will not automate institutions evenly either.

It works best on local moves: bounded, familiar, pattern-rich tasks whose outputs can be quickly inspected, tested, or revised.

It struggles when those moves must preserve system invariants: security, correctness, accountability, safety, legality, reliability, legitimacy, or architectural coherence.

The hardest cases are not hard because nobody can generate the next artifact. They are hard because the artifact must fit inside a chain of trust.

AI can make answers faster. Institutions exist to make answers trustworthy.

1. Start with the too-simple AI story

There is a tempting story about AI:

AI is automating software. Bureaucracy is next. Slow institutions will finally move at software speed.

But this story is wrong in two ways.

First, AI is not automating all software. It is mostly accelerating the legible, repeatable, locally checkable parts.

Second, institutions are not slow only because they are inefficient. Some are slow because institutional trust is slow to produce.

The better question is not:

Can AI automate this domain?

It is:

Which parts of this domain are local, legible, and checkable — and which parts are entangled, invariant-bearing, and accountable?

2. AI is good at local moves

AI is excellent at bounded tasks:

  • write the component;
  • draft the memo;
  • summarize the file;
  • generate the test;
  • compare the policies;
  • produce the first pass;
  • classify the ticket;
  • scaffold the interface.

These are local moves.

A local move is useful because it reduces the cost of producing an artifact. The context is limited, the pattern is familiar, and the result can usually be inspected quickly.

In software, local moves include frontend specs, CRUD screens, API wrappers, boilerplate, test scaffolds, small refactors, and repeated integrations.

In institutions, local moves include summarizing documents, extracting facts, drafting memos, finding precedents, comparing policies, routing cases, and producing first-pass analysis.

These are real tasks. Automating them matters.

But they are not the whole system.

3. Even software has deep institutional parts

Not all software is easy for AI.

LLMs are good at repeated patterns and locally checkable outputs. They struggle with mature systems where every change touches hidden invariants:

  • security assumptions;
  • permission models;
  • customer promises;
  • operational habits;
  • performance constraints;
  • architectural boundaries;
  • historical incidents encoded in strange code;
  • business rules nobody has fully written down.

Deep software is not hard because code is hard to type.

It is hard because every local change must preserve a larger system.

A mature codebase is not just source files. It is institutional memory made executable.

4. Institutions are built around trust, not throughput

This is even more obvious in law, engineering, medicine, finance, and government.

These systems are not primarily optimized for speed. They are optimized for legitimacy, accountability, and durable trust.

A court is not just an answer machine.

An engineering review is not just a design optimizer.

A regulator is not just a classifier.

A hospital is not just a diagnosis pipeline.

They are systems for turning judgment into decisions that others can trust.

That is why treating institutional slowness as mere inefficiency misses the point. Some slowness is waste. But some slowness is the work of trust production.

5. Why institutional trust is slow

Institutional trust is slow because it requires several conversions.

Private judgment → public reasons

Someone may privately know what they think.

But an institution needs reasons that can be written down, inspected, challenged, and understood by others.

A judge cannot merely say, “seems right.”

An engineer cannot merely say, “the model liked this design.”

A regulator cannot merely say, “the pattern looked suspicious.”

The decision has to become public reasons.

Output → record

The decision has to leave a durable trail.

What evidence was considered? What rule was applied? Who approved it? What alternatives were rejected? What uncertainty remained?

The institution is not only deciding for the present. It is preserving a record for future review.

Authority → responsibility

Someone must be authorized to decide, and someone must be responsible for the consequence.

AI can produce an answer. It cannot automatically absorb institutional responsibility.

That responsibility has to land somewhere: a person, a role, a committee, an office, a profession.

Decision → contestable process

Many institutional decisions must be contestable.

An affected party may need to ask:

  • Why did this happen?
  • What evidence was used?
  • Was the correct rule applied?
  • Who had authority?
  • Was there bias, negligence, or error?
  • Can I appeal?

A decision that cannot be contested may be fast, but it is not institutionally trustworthy.

6. AI threatens to compress the slow part

AI is powerful because it compresses work.

It reads faster. Drafts faster. Summarizes faster. Connects facts faster. Generates options faster.

But in institutions, the slow part is often where trust is produced.

If AI compresses the reading but loses the evidence trail, that is not progress.

If AI drafts the rationale but nobody knows whether it is the real rationale, that is not legitimacy.

If AI recommends the decision but no one can reconstruct why, that is not institutional trust.

It is just faster opacity.

7. The real automation boundary

The useful question is not:

Can AI do this task?

The useful question is:

What kind of trust does this task require?

If trust comes from fast feedback, testing, reversibility, and easy inspection, AI can move quickly.

If trust comes from records, reasons, authority, review, contestability, and responsibility, AI must move more slowly.

That boundary runs through both software and institutions.

It separates local moves from invariant-preserving moves.

8. Design implication

In trust-bearing domains, good AI systems will not simply remove steps.

They will help produce better trust artifacts:

  • clearer records;
  • better citations;
  • explicit assumptions;
  • reviewable drafts;
  • structured rationales;
  • issue logs;
  • provenance trails;
  • escalation paths;
  • decision histories;
  • preserved uncertainty;
  • explicit handoff points.

The goal is not maximum autonomy.

The goal is better judgment with better evidence.

9. Closing shape

AI will transform software and institutions, but unevenly.

It will move fastest where work is local, legible, reversible, and checkable.

It will move slowest where decisions must be public, durable, contestable, and owned.

That is not because those institutions are backward.

It is because trust is not produced at the speed of generation.

Possible final line:

AI can make answers faster. Institutions exist to make answers trustworthy.