Regulatory Functions

MASD asks two questions of any corpus of hand-written material: which of its structure is mechanically reproducible, and what should replace that structure once it has been found. Code generation is the setting in which the questions were posed rather than their content, and they survive being asked of another population of artefacts.

The skills catalogue is such a population. MASD therefore supplies a method rather than a conclusion, and that distinction governs what follows: the analysis transfers whole, and Divergence in the Remedy sets out where the remedy does not.

MASD's physical modelling process runs in five stages. It samples representative hand-written artefacts, decomposes each into its parts, classifies those into parts and facets, reconstructs each recurring pattern as an archetype, and catalogues the archetype with its variability exposed.

The analysis behind this framework ran the same five stages over a different population, our own catalogue together with three published collections. It decomposed each skill into the judgement, sequence, command and fact it carried, classified those into regulatory functions, reconstructed the uniform cases as a computed table, and catalogued the result with the declarations that parameterise it.

Three findings follow, each a MASD construct instantiated in the new population.

• Regulatory Functions and facets. MASD defines a facet as "an arbitrary partitioning/taxonomy of the logical space", classifying entities "by the role each artefact plays". A regulatory function is a construct of the same kind on a different axis: it classifies by the agent's relation to an artefact rather than by the artefact's place in the physical model. MASD's description of the facet as arbitrary applies to it unchanged, so a taxonomy of this kind is stipulative rather than descriptive, justified by what it makes possible rather than by correspondence to a natural kind in the material. The two differ in exclusivity: a facet partitions, while regulatory functions are not mutually exclusive and one type may carry several.
• Addressing. MASD addresses an artefact by a four-segment path, [technical space].[part].[facet].[archetype], so that its location follows from its classification rather than from memory. The framework addresses an operation by the pair of target type and verb for the same reason, and Skill dispatch treats the consequence.
• Schematic and repetitive patterns. MASD's central construct is the Schematic and Repetitive Pattern in Physical Space: content that "varies predictably across entities but is otherwise mechanically identical", and is therefore generated rather than written by hand. Write \(T\) for the set of target types and \(V\) for the set of verbs. A catalogue holding one document for each admissible pair in \(T \times V\) is such a pattern, since those documents differ only in the two coordinates that index them. The limitation the definition addresses is consequently an SRPP in the skills catalogue, and it is the finding on which the framework's response turns.

The test is operational in both cases. MASD holds that "one determines if a physical pattern is schematic and repetitive by reproducing it by automated means"; the framework holds that a verb table which cannot be generated is a table that should not be built.

The two diverge over what to do once the pattern has been identified. MASD resolves an SRPP by generating the instances, which thereafter exist as files. The framework resolves the same pattern by declining to produce the instances at all: the pairing of verb and target type is computed when a target is dispatched, and no skill document is written for any pairing (Skill dispatch).

The divergence follows from the consumer. A compiler is indifferent to how many files it is handed, so materialising every instance costs nothing and buys locality. An agent is not indifferent. Its catalogue is read rather than compiled, and the size of that catalogue is itself the cost, because every entry competes for attention at the moment of selection. Generating one skill for each pairing would reproduce the pattern faithfully and reinstate the very problem the analysis was undertaken to solve.

MASD's own test survives the divergence, since reproduction by automated means is satisfied by computing the pairing as well as by writing it out. What the framework takes from MASD is the analysis: how to recognise mechanically reproducible structure, and how to name the axes along which it varies. Code generation is where the borrowing stops.

One MASD principle bears on the section that follows. Evolve Gradually directs that coverage grow "driven by concrete practice rather than up-front design", which is the ground for declining to claim the six values below are exhaustive.

If a regulatory function is the same kind of object as a MASD facet, the framework owes an account of why it does not simply declare six facets and stop. There are three reasons, and the first is a matter of fact rather than of theory.

A document type implements one or more regulatory functions, each declaring the operations available on it. The term is not borrowed; it names what the derivation establishes, and it is answerable to that account rather than to convenience.

Two properties of the classification matter here. A type may implement several functions: a recipe implements loading, being consulted for its command, and execution, its script being run. A classification permitting one membership per type could not express that, and an earlier attempt failed on exactly this case. And an operation whose behaviour does not vary across implementing types is written once rather than once per type, which is what keeps the catalogue from growing as the product of operations and types.

Three alternatives were rejected. Function unqualified collides three ways: the literature on the Viable System Model uses it interchangeably with System for S1 to S5, Liu et al. name their construct a program function, and the project is written in a programming language. Channel carries information and has a capacity in cybernetics, which describes six of the seven but misdescribes execution. Facet is MASD's term for a different partition of the same artefacts, treated above.

An earlier framing of this classification was Gibsonian. The connection is recorded because one part of it still does work, and because the difference between the two framings is instructive.

Gibson coined affordance in The Senses Considered as Perceptual Systems (1966) and stated it in The Ecological Approach to Visual Perception (1979):

The affordances of the environment are what it offers the animal, what it provides or furnishes, either for good or ill.

That framing classified an artefact by what it offers an agent. The criterion defended here is different in kind: a document type is classified by the regulatory function it supplies, and the seven are derived from the primitives of a control loop rather than observed in the material (The Cybernetic Skills Framework). The two agree on almost every assignment and disagree on their grounds. A derivation is what the earlier framing lacked, and without one there was no answer to the question of whether some further class existed.

One element survives independently of the framing that carried it. Norman narrowed affordance in 1988 to those possibilities an actor can readily perceive. That narrowing justifies a requirement the framework would otherwise hold without explanation: a regulatory function an agent cannot detect is one it will not use, which is why an artefact must declare what it implements rather than leaving it to be inferred.

The first division the criterion makes is between loading and everything else, and it is the one that carries the most consequence.

An artefact engaged under the loading function contributes to what an agent knows before it decides anything, and it carries no procedure of its own. An artefact engaged under any of the other five contributes to what the agent does, and it always carries one. Loading is therefore the only regulatory function that changes the agent rather than the work.

An artefact may offer more than one regulatory function, and the recipe does. This is a consequence of the term rather than an exception to it: a regulatory function is a relation, and nothing prevents an artefact standing in several.

The framework requires only that every artefact offer at least one, which the criterion guarantees, since an artefact standing in no relation to an agent has no place in a catalogue an agent uses. It does not require that the offers be disjoint, and a partition would be the stronger claim it does not need.

The router is a second plural case. It declares a System, matches a method and dispatches, so it is engaged under sequencing and under execution at different points in its own operation.

The types below supply the material an agent brings into working knowledge before it acts, and the process of doing so is grounding. They differ in the question each answers and in the condition under which each is read, and the distinctions are necessary ones: a framework that treats them alike cannot say when each should be consulted.

A stance is a general rule of judgement. It constrains how a choice is made without prescribing what is done, which is why it has no procedure and produces no artefact: there is nothing in a stance to execute. An agent invokes one by citing it against a specific decision, and the citation is admissible only when it names the choice the rule changed. A principle cited without an accompanying decision records nothing and may be disregarded.

Two contrasts fix the boundary. A stance differs from a method in that a method orders actions through time whereas a stance constrains the choices made within them; the two compose, and a method's phases routinely cite several. A stance differs from a recipe in that a recipe is executed and leaves the system changed, whereas a stance leaves no trace except in the reasoning that produced a decision.

Citation is the one place where an artefact that cannot be run is nevertheless a skill. That exemption is deliberate and narrow: a principle which cannot be loaded by name cannot be cited by a method, and a rule that cannot be cited cannot be shown to have been applied.

The academic literature reviewed in Skills in the Compass Skill Framework bears on this regulatory function, and it does not favour it. That review finds a rule expressed as text states what an agent should do in principle without stating when it applies, and reports such rules being disregarded in practice. The regulatory function is therefore constituted as a residue rather than as a preference: a rule that can be expressed as a check, whether a lint, a validator or a test, is written as one and does not enter the regulatory function, which holds only what cannot be checked. A stance regulatory function that fails to shrink as checks accumulate is evidence that the requirement is not being applied.

A method is an ordered sequence of phases carrying a piece of work from an unverified beginning to a verified end. It is defined over a shape of work — a defect to be diagnosed, a behaviour to be added, a structure to be changed — rather than over any particular artefact, and it therefore names no specific command. A method is control flow without effectors.

Indexing by shape of work is the axis on which the pstack collection organises its entire catalogue, as the review of industrial collections in Skills in the Compass Skill Framework records. Here it governs one regulatory function among six, the artefact axis being carried by actions, so the two axes compose rather than compete.

The phases of a method are adaptive rather than fixed. Which of them run and in what order depends on what the work reveals as it proceeds, so a method's correctness is a property of the judgement it encodes rather than of the system it runs against. This is the principal difference between a method and a recipe. The two are treated together below, since the distinction between them accounts for most misclassification in practice.

A recipe answers how is this operation performed here? A method answers how is this class of work approached? From that difference the rest follows.

Two tests settle any case that remains unclear. The first is determinism: where the steps are the same on every run the artefact is a recipe, and where they depend on what is found it is a method. A method that never branches is a recipe that has acquired phases it does not need; a recipe qualified throughout by "it depends" is a method that has not yet been written.

The second test is direction of dependence. A method's phase cites a recipe; a recipe never cites a method. Where a recipe finds itself explaining when it should be run, judgement has leaked downward and belongs to a method. Where a method finds itself spelling out a command, an effector has leaked upward and belongs to a recipe.

An action is a single operation applied to one typed artefact, together with the judgement governing its use: what must hold before it runs, what state it leaves behind, and what to do when its guards refuse. The command it issues belongs to a recipe, which the action delegates to; what the action itself owns is the decision to issue it.

Recipe, action and method therefore divide cleanly. A recipe holds the command, an action holds the judgement about that command, and a method holds the sequence in which such judgements are made. Each has exactly one source of truth, and drift in any of them has exactly one place to appear.

Actions are the regulatory function where uniformity is worth exploiting. Where a verb behaves the same way across artefact types it becomes a single skill driven by a generated type table; where its procedure genuinely differs per type it keeps a skill of its own. The test is whether the procedure differs, not whether the artefact does.

A specification states intended behaviour in a form a machine can check, and from which tests are generated. Its defining property is that it is normative: it says what the system ought to do, which is what separates it from knowledge, whose claims are descriptive. The consequence matters. Where a knowledge document disagrees with the system the document is wrong and is corrected; where a specification disagrees with the system, which of the two is wrong is an open question, and the disagreement is a finding rather than an error.

That property is what allows a specification to make a method's definition of done falsifiable rather than rhetorical. A method's framing phase writes or extends a rule; its verification phase runs the tests propagated from that rule. In this project specifications are written in Allium.

Deliberation is the procedure by which a contested judgement is settled when the available evidence cannot settle it. A method convenes one at a fork it cannot resolve, and the product is a verdict recorded against the work, never a silent change to the code.

The contrast with verification is what fixes deliberation's place. Verification establishes whether a claim is true and is answerable by a checker; deliberation decides what should be done where no checker can yet answer, and its output is a reasoned position rather than a fact. Confusing the two in either direction is costly. Sending a checkable question to deliberation wastes it, and sending an unanswerable one to a checker produces a confident verdict with nothing behind it.

Deliberation in this project is provided by the Council of High Intelligence, consumed as an external plugin. Its instrument is a panel of analytically distinct personas, and the limitation that follows should be stated wherever it is relied upon: personas vary framing but share the priors of the single model beneath them, so deliberation is a strong instrument for surfacing a tradeoff and a weak one for detecting an error. Error detection routes instead to the checkers set out in Verification and evaluation, which do not share those priors.

An artefact implements recording when it carries a lifecycle that an agent advances. A task moves from BACKLOG through STARTED to DONE and receives a Result when it closes; a capture moves between the backlog's folders as its disposition is settled. Advancing the artefact is not incidental to it. It is what the artefact exists for, and it is how the state of work is held.

The regulatory function has a mechanical test, which is why its assignment is checkable rather than a matter of judgement: a type implements recording when it declares a lifecycle, whether as a TODO vocabulary in its frontmatter or as a position among folders. Task, story, sprint, version and test scenario declare the first; capture uses the second. Knowledge, recipes, runbooks, memories and skills declare neither and afford no recording.

Recording pairs against declaration rather than duplicating it. A declaration states what ought to be true, which for a task is its acceptance criteria. A recording captures what happened: the state reached, the result written, the plan as it was actually worked.

Every artefact additionally offers being operated on: edited, moved, renamed, deleted. That regulatory function is universal, and a property every member of a population shares carries no classificatory information, which is why it is absent from the seven above.

It is not absent from the framework. Operating on an artefact is what an action does, and the population an action may operate on is wider than the population classified here, since it includes targets that are not artefacts at all. Skill dispatch treats that population and the operations registered against it.