# The author is probabilistic

> This section covers what architecture means when a model writes the code, as shown in three authors], and the finding that reaches the model, typed in [a…

Page: Architecture · Scale
Canonical: https://banes-lab.com/software-architecture/scale#the-author-is-probabilistic

This section is stop 100 of 102 in the learning route. Previous: [03 - Above one tier, reduction](https://banes-lab.com/software-architecture/scale/above-one-tier-reduction.md). Next: [05 - Scale follows determinism](https://banes-lab.com/software-architecture/scale/scale-follows-determinism.md). It builds on [01 - From intent to predicate](https://banes-lab.com/software-architecture/coverage/an-architecture-is-its-predicate-set.md), [01 - An anti-pattern is a decay path](https://banes-lab.com/software-architecture/decay/an-anti-pattern-is-a-decay-path.md), [02 - Seven controls, seven classes](https://banes-lab.com/software-architecture/decay/seven-controls-seven-classes.md), [02 - Who does what](https://banes-lab.com/disciplined-methodology/start/who-does-what.md), [17 - Detect, log, fix](https://banes-lab.com/disciplined-methodology/build/detect-log-fix.md).

This section covers what architecture means when a model writes the code, as shown in [D1·a three authors](https://banes-lab.com/software-architecture/scale#the-author-is-probabilistic-panel-a), and the finding that reaches the model, typed in [D1·b a finding record](https://banes-lab.com/software-architecture/scale#the-author-is-probabilistic-panel-b). The same three parties are derived from the tooling's side in [who does what](https://banes-lab.com/disciplined-methodology/start/who-does-what.md) on the methodology page.

### Every principle becomes a gate

Development with a model scales code production and leaves architecture where it was, held by intentions the model does not keep. An edit is judged clean by the model's own read of it, the check that would have disagreed never ran, and the design principle the edit violates is still the first paragraph of the document the model was given. A model's adherence to an instruction is a distribution rather than a commitment, so an architecture that rests on adherence is a bet placed on every change.

For this reason the architecture is the set of predicates the gate holds, and design is choosing them. Design is spent on choosing predicates rather than on explaining intentions to the model. In practice, the seven controls are installed as checks before the model writes anything, and every architectural intent is treated as unenforced until its predicate runs in the chain. The model's authority is bounded, so every model-produced artifact is validated at the boundary it crosses and raw model output never reaches a trusted sink. The model is directed with findings rather than principles, in [the loop](https://banes-lab.com/disciplined-methodology/start/the-loop.md) described in [detect, log, fix](https://banes-lab.com/disciplined-methodology/build/detect-log-fix.md) on the methodology page.

To check this, delete the design document from the session and run the gate. Whatever the gate refuses is the architecture that exists. Whatever it accepts that the document forbade was never architecture, and the model has been writing it since the first session. The model is not the reviewer and the gate is not the designer. A gate decides whether a predicate holds and nothing about whether the predicate was worth stating. That decision stays with the developer, and a system whose predicates were chosen by the model has let the author grade its own work.

### Who does what

The division of labour follows from the author being a model. The tooling detects because detection is deterministic and a model's account of its own work is not. The model is asked to remediate because a finding is a task it is likely to perform consistently. The developer governs because choosing the predicates and deciding the tensions is not computed.

The arrangement is [policy enforcement](https://banes-lab.com/records/arch/policy-enforcement.md), with the policy held as code and the enforcement held by a gate, and it is the only arrangement in which an [agentic architecture](https://banes-lab.com/records/arch/agentic-architecture.md) keeps an architecture at all. [Prompt engineering](https://banes-lab.com/records/arch/prompt-engineering.md) can raise the odds that a model honours an intent. It cannot make the intent hold, because a probability is not a predicate.

### A finding is the contract

A finding is machine-actionable for exactly this reason, and its shape is described in detect, log, fix on the methodology page. [Auto-remediation](https://banes-lab.com/records/arch/auto-remediation.md) takes the findings with [one correct answer](https://banes-lab.com/disciplined-methodology/verify/one-correct-answer.md), and the rest route to the model with their operands already resolved.

[Ungrounded content](https://banes-lab.com/records/arch/ungrounded-content.md) is the failure this shape prevents. A model told a principle is likely to produce a plausible reading of it. A model handed a finding is asked to make the one change the finding names, and the gate that produced the finding is the same gate that checks the change, so the loop closes on evidence rather than on the model's report of itself.

D1·a three authors

```mermaid
flowchart TB
intent["An architectural intent"]
author{"Who writes against it?"}
person["The developer · complies by attention · drifts slowly"]
model["A model · complies probabilistically · produces locally reasonable changes at speed"]
gate["A gate · the only party in the loop that refuses"]
holds["The intent holds by construction"]
decays["The intent decays at the author's speed"]
intent --> author
author -- developer --> person -. eventually .-> decays
author -- model --> model --> decays
model -- every intent as a predicate --> gate --> holds
```

D1·b a finding record

```typescript
export interface Finding<Shape> {
readonly at: Location;
readonly mismatch: { readonly expected: Shape; readonly found: Shape };
readonly remediation: { readonly operation: Operation; readonly operands: readonly Operand[] };
}

export const route = (finding: Finding<unknown>): "heal" | "delegate" =>
finding.remediation.operands.every((operand) => operand.resolved) ? "heal" : "delegate";
```

## Links to

- [Who does what](https://banes-lab.com/disciplined-methodology/start/who-does-what.md)
- [The loop](https://banes-lab.com/disciplined-methodology/start/the-loop.md)
- [Detect, log, fix](https://banes-lab.com/disciplined-methodology/build/detect-log-fix.md)
- [Policy Enforcement](https://banes-lab.com/records/arch/policy-enforcement.md)
- [Agentic Architecture](https://banes-lab.com/records/arch/agentic-architecture.md)
- [Prompt Engineering](https://banes-lab.com/records/arch/prompt-engineering.md)
- [Auto-Remediation](https://banes-lab.com/records/arch/auto-remediation.md)
- [One correct answer](https://banes-lab.com/disciplined-methodology/verify/one-correct-answer.md)
- [Ungrounded Content](https://banes-lab.com/records/arch/ungrounded-content.md)

## Linked from

- [Who does what](https://banes-lab.com/disciplined-methodology/start/who-does-what.md)
- [Detect, log, fix](https://banes-lab.com/disciplined-methodology/build/detect-log-fix.md)
- [One correct answer](https://banes-lab.com/disciplined-methodology/verify/one-correct-answer.md)
- [The developer and the model](https://banes-lab.com/disciplined-methodology/collaborate/the-human-and-the-ai.md)