PRI-PR-001 · PrinciplesRev 0.1 · Draft

A method for building software with AIPrinciples

Document
PRI-PR-001
Status
Draft
Applies to
SaaS, games, sites

Generation is cheap. Deciding what to generate, and knowing whether it is right, is not.

Priori organises software work around that fact. A priori: known before experience. Decide what is true before an agent writes it, and keep those decisions as the asset.

Companion to PRI-OM-001i
PRI-PR-001 · 100.00 SoftwareRev 0.1 · Draft

100.00

A model is software

100.01

A language model is a program: a fixed set of trained weights that turns a sequence of tokens into a probability for each possible next token, sampled one token at a time. Between calls it keeps nothing. Anything it “remembers” is text that other software put back into its input.

100.02

An agent is also a program: a loop of model, harness and tools. Its abilities belong to the loop, and so do its failures.

Agent = model + harness + tools, in a loop Context instructions, files,history, tool results Model fixed weights;samples the next token Harness parses the output,calls a tool Tools shell, editor,tests, search no state between calls result appended to the context · repeat until done or stopped
Fig. 100.01 — The agent loop. Everything the agent knows on a given call is in the left-hand box.
100.03

A model has no goals that outlast the call and no stake in the outcome. A reasoning trace is generated text that tends to improve the answer; it is not a reliable record of how the answer was reached.

100.04

Priori treats a model as a stochastic component and engineers it as one. Pin the version and test upgrades like any dependency. Verify every output. Never use a model where a function will do: a compiler, type checker, test or query is deterministic and cheap, and one belongs behind every model.

100.10 Say what happened
Instead ofSay
“It lied.”It output a claim with no source, and nothing required one.
“It understands the codebase.”The relevant files were in its context.
“It forgot.”That fact was not in this call’s input.
“It got lazy.”The task had no check for it to fail.
“It wants to help.”It was trained to produce answers shaped like this one.
1
PRI-PR-001 · 200.00 The minimum systemRev 0.1 · Draft

200.00

The minimum system

200.01

Every project is a system of four parts: You (intent), the Agent (action), Tasks (work) and the Vault (memory). Four points is the fewest that enclose a space; Fuller calls the tetrahedron the minimum system (Synergetics 400.00). Remove a part and the system does not close.

200.02

Each of the six edges is an interface, and most failures happen on an edge rather than inside a part. Give every edge an artifact. Nothing lives only in the chat.

YouTasksVaultAgent 123456
Fig. 200.01 — Four parts, six interfaces. Edge 6 runs behind you, so it is drawn dashed.
RefInterfaceArtifact
1BriefYou → AgentSpec, acceptance checks, change dials
2ReadVault → AgentDesign and brand specs, decision records
3WorkAgent → TasksTicket, branch, diff, handoff
4ReportTasks → YouResult against its checks
5RecallVault → YouHistory, decisions and their reasons
6RecordTasks ↔ VaultWhat the work writes back to memory, without you
200.03

The method does not depend on the domain. A SaaS product, a game, a library and a marketing site each have an intent, an actor, units of work and a memory. Name where each lives before building.

Check: you can point to one place for each part and one artifact on each edge2
PRI-PR-001 · 300.00 The dynamo problemRev 0.1 · Draft

300.00

The dynamo problem

300.01

Electric motors were practical by the 1880s, yet in 1899 they supplied under 5% of the mechanical power in American factories. Most early adopters replaced the steam engine with one large motor that turned the same line shaft, and kept the building, the layout and the work arranged around it.

Group drive · c. 1900 motor One motor turns one shaft. Machines sit where the shaft runs. Unit drive · 1920s A motor in each machine. The floor follows the work.
Fig. 300.01 — Group drive and unit drive. The same motors; a different factory.
300.02

The gains came with unit drive, a motor in each machine. Once power no longer ran along a shaft, plants could be single-storey, laid out by the flow of work, with lighter buildings and different jobs. Paul David drew the lesson for computing in 1990: a general-purpose technology pays off only after the work is reorganised around it, and that takes decades.

25%50%75%100% under 5% 1899 about 25% 1909 55% 1919
Fig. 300.02 — Electric motors’ share of installed mechanical drive in US manufacturing. Historical Statistics of the United States; 1909 computed from the series.
300.03

Most AI adoption today is the motor on the line shaft. The agent is bolted onto a process built around a constraint that has gone: the scarcity of human typing time. Sprints, story points, line-by-line review, pull-request size limits and ten-person teams are all ways of rationing code. When code is no longer scarce, the rationing becomes the bottleneck.

before adoption METR, early 2025: tasks took 19% longer; developers believed they were 20% faster after the floor is rebuilt time →
Fig. 300.03 — The productivity J-curve (Brynjolfsson, Rock and Syverson, 2021). Stylised; the METR point marks where bolted-on adoption sits.
300.04

The transition costs output before it returns it. Experienced developers in METR’s 2025 study were slower with AI on their own mature repositories while believing they were faster. That is the bottom of the curve: a new motor turning the old shaft.

300.10 Unit drive for software: re-lay the floor around judgment and verification
PartFloor built for scarce codeFloor built for scarce judgment
Unit of workSprints and story pointsA task an agent can finish against one check
Source of truthThe codeThe decisions in the Vault; code is regenerated from them
ReviewLine by line, after the factA designed verification stage with its own checks and people
TeamTen people, most of them typingFour people ordered by judgment, each with agents
MemoryHand-off documents and whoever remembersRecords the work writes as it goes
MeasureLines, tickets, velocityOutcomes against checks
SEE 700.00 Sources3
PRI-PR-001 · 400.00 What models are forRev 0.1 · Draft

400.00

What models are for

400.01

Models are strong where the output can be checked and the pattern is common in their training data. They are weak off the distribution, where exactness is required, and where the judge is the same component as the author. Design every task so its output can be checked.

Delegate with edge casestest every boundary Delegatethe check decides Keep with Youdecide, then split it Draft, then reviewYou judge the result boilerplateunfamiliar APIrecursive file walknaming and copyarchitecturewhat to build pattern is common in training data → output can be checked →
Fig. 400.01 — Where to delegate. Move work up the chart by writing the check; move it right by decomposing it into common patterns.
400.02

The strengths, in order of reliability: breadth, taking an unfamiliar language, API or domain to a working first version; translation between representations, from spec to code, code to tests and code to docs; iterating against a check far past human patience; search, extraction and summary at volume; and applying a known pattern.

400.10 Weaknesses and their controls
WeaknessSeen asControl
Edge cases outside the training dataIn one study every frontier model walked only the top-level files of a directory; none recursed.List the boundaries in the spec; test each one.
Consistency across a codebaseRepositories that adopted Cursor gained velocity briefly and kept the added technical debt.Decisions in the Vault, conventions as lint rules, reuse before adding.
Exactness: counts, pixels, colours, arithmeticValues read off an image or estimated in prose.Measure with a function.
Grading its own workTwo-thirds of developers call AI output “almost correct, but not quite”.A check or a refuter that did not write the work.
Knowing what it does not knowConfident answers with invented sources or dependencies.A citation or a check for every claim; doubt counts as refuted.
Stability across runs and versionsThe same prompt yields different code; an update changes behaviour overnight.Pinned versions, acceptance checks, regression evals.
400.20 Models by type. Classes, not names: names change every quarter, so pin the name in the project.
TypeGood forNot forCheck behind it
Frontier reasoningArchitecture, cross-module debugging, spec critique, refutation, risky reviewsVolume work, or anything a smaller model passesA second refuter, or your decision
General mid-tierBounded implementation from a clear spec, refactors, testsOpen designTests, type checks, review
Small and fastSearch, extraction, classification, routing, summariesJudgment; synthesis across many sourcesCited spans, re-read before use
Inline completionThe next few lines at the cursorAnything beyond the cursorThe compiler
EmbeddingRetrieval, deduplication, clusteringGeneration or exact matchSpot-checked recall
Image and videoConcepts, mood, texture, placeholder artMarks, type, exact geometry, anything redrawn identicallyYour pick; final assets made by code or by hand
Speech to textTranscription, locally and privatelySpeaker attribution without reviewReview of the excerpt you use
Deterministic toolsEverything they cover: compilers, linters, tests, queries—They are the check
400.03

Route each task to the cheapest type that passes its check. When it fails, rerun it one level up with the failure attached. Deciding what to build stays with You.

4
PRI-PR-001 · 500.00 PrinciplesRev 0.1 · Draft

500.00

Principles

  1. 510

    Decide before generating

    A priori: settle what is true before an agent writes it. Generation multiplies whatever the spec gets wrong, so the spec is the cheapest place to fix it.

    CheckA problem found in review is traced to a spec line and fixed there first.

  2. 520

    Pattern over material

    A knot can slide along a rope: the knot is the pattern, the rope is material passing through it. In software built with agents the decisions are the pattern and the code is the material. Code can be regenerated; a lost decision cannot.

    CheckAn agent given only the Vault could rebuild the module to the same checks.

  3. 530

    Triangulate

    The triangle is the only polygon that holds its shape with pinned joints. A claim held only by spec and implementation can swing between them; an independent check fixes it in place.

    CheckNothing is done until a check the author did not write passes. SEE Fig. 500.01.

  4. 540

    Make it checkable

    A task without a check is not ready to delegate. Write the check first, or as part of the spec. Models are strongest exactly where a check exists.

    CheckEvery delegated task states its acceptance as a command or a measurement.

  5. 550

    Tension, not mass

    Tensegrity holds islands of compression in a continuous net of tension (Synergetics 700.00). Lock a few things hard; hold the rest with tests, budgets and change dials. A lock opens only when its owner names it.

    CheckEvery layer is locked, with a date and an owner, or governed by a dial.

  6. 560

    Change the environment

    Fuller argued for reforming the environment rather than the people in it. For a model, the environment is the context: instructions, skills, hooks and checks.

    CheckA correction made twice becomes a rule, a skill, a hook or a test.

  7. 570

    Ephemeralization

    Do more with less (Fuller, 1938). Generating code keeps getting cheaper; carrying it does not. Spend the savings on cutting.

    CheckThe system has the fewest parts that pass its checks; each addition names what it replaces.

SpecImplementation two points: swings SpecImplementationIndependent check three points: holds
Fig. 500.01 — Triangulate. A third point that the author did not set fixes the shape.
580

The simplest system. Every rule above reduces to one: build the fewest parts that close the system, and put a check on every edge. One line, one node, one accent. A proposal that adds a second way to do the same thing fails before anyone argues taste.

5
PRI-PR-001 · 600.00 PeopleRev 0.1 · Draft

600.00

People

600.01

Judgment flows up; execution flows down. Agents execute. Junior engineers direct agents, verify their output and escalate. Senior engineers direct juniors, decide architecture and keep their own agents for review and monitoring.

judgment execution Senior reviewmonitor Junior features codetest Junior bugs codereview Junior infrastructure codedocs
Fig. 600.01 — Four people and their agents. The junior role is the verification stage.
600.02

Judgment comes only from practice. A team that stops hiring juniors is eating its seed corn: today’s juniors are the only source of tomorrow’s seniors. Directing and verifying agents is the fastest apprenticeship in judgment the field has had.

600.03

Measure outcomes against checks, not lines written or tokens spent.

700.00 Sources

  1. 700.01

    Paul A. David, “The Dynamo and the Computer: An Historical Perspective on the Modern Productivity Paradox”, American Economic Review 80(2), 1990, 355–361.

  2. 700.02

    Warren D. Devine Jr., “From Shafts to Wires: Historical Perspective on Electrification”, Journal of Economic History 43(2), 1983, 347–372.

  3. 700.03

    Erik Brynjolfsson, Daniel Rock and Chad Syverson, “The Productivity J-Curve”, American Economic Journal: Macroeconomics 13(1), 2021, 333–372.

  4. 700.04

    METR, “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity”, July 2025.

  5. 700.05

    R. Buckminster Fuller, Synergetics, 1975: 400.00 System; 700.00 Tensegrity.

  6. 700.06

    R. Buckminster Fuller, Nine Chains to the Moon, 1938 (ephemeralization).

  7. 700.07

    Historical Statistics of the United States, series Dd848–853 (installed horsepower in manufacturing).

  8. 700.08

    Stack Overflow Developer Survey 2025 (“almost correct, but not quite”).