jonnifyagile agents
jonnify / Agile Agent Workflow / A1 · Why / A1.02 · Pragmatic Programming, revisited for agents

A1.02 · Why an Agile Agent Workflow

Pragmatic programming, revisited for agents

The Pragmatic Programmer's habits were written for a person typing every line. Hand the typing to a Claude agent and the principles do not vanish — three of them get more important, because the cost of producing code falls and the cost of owning it does not.

One inversion carries the module: when generation is cheap, the things that were always expensive get relatively more expensive. Duplicating, leaving things ambiguous, and adding surface area all got cheaper; keeping a fact consistent, specifying a unit precisely, and bounding a change all did not. So DRY, Design by Contract, and Orthogonality are re-weighted upward — each a discipline the human owns and points the agent at.

The inversion The three dives References

When generation is cheap, the bill moves

The canon was written against the cost of writing software by hand. That cost is what an agent removes: it will produce code, duplicate a fact, or add another module as fast as you can ask. What it does not remove is the cost of owning the result — keeping a duplicated fact in sync, pinning down what a unit is supposed to do, and re-checking everything a change might have touched.

So the pragmatic principles do not retire; they re-weight. Three in particular move from convenience to discipline, because each answers one of the costs that did not fall. Naming them is the whole module; each dive takes one, re-reads it for the agent era, and grounds it on the Portal.

The inversion · three principles, re-weighted

CHEAPER TO PRODUCE — the agent's gift duplicating knowledge ambiguous code more surface area DRY the single source of truth Design by Contract the contract is the spec Orthogonality decoupling for review drift ambiguity blast radius MORE EXPENSIVE TO OWN — the bill that stays
Three things an agent makes cheap to produce — duplicating knowledge, leaving code ambiguous, and adding surface area — press down on three costs that did not fall: drift, ambiguity, and blast radius. The pragmatic principle pinned between each pair is the discipline that answers it — DRY against drift, Design by Contract against ambiguity, Orthogonality against blast radius.
the principle

The pragmatic canon was written for a person typing every line. It holds — but cheap generation re-weights three of its principles from convenience into discipline.

on the Portal

One id authority (Portal.ID), one id contract, and surfaces behind facades — knowledge, specification, and structure the agent is pointed at, never asked to re-derive.

The canon does not retire when the agent arrives; it is re-weighted — and the three principles that rise are the ones that keep an agent's work ownable.

The three dives

Each dive takes one re-weighted principle in the arc knowledge → specification → structure: where a fact lives, how a unit is specified, and how units stay independent. Read them in order — A1.02.1 starts.

A1.02.1built

The single source of truth

DRY re-read: duplication is a drift surface the agent creates for free and you reconcile by hand. One authority is the only price that does not grow.
A1.02.2built

Design by contract

The precondition, postcondition, and invariant triple as the precise specification an agent implements against and you accept against — without reading every line.
A1.02.3built

Orthogonality and blast radius

Decoupling keeps a change's blast radius small, so an agent's diff stays inside what one human can review. The structure that keeps the units independent.

After A1.02, the next module — A1.03 · The Author/Operator loop — turns these principles into the cycle that runs every rung. Return to the A1 module navigation to continue.

References

The canon this module re-reads, and where each principle lands in the course.

Sources

Related in this course