When to use which: paradigms and architectures

type Job = { ships: boolean; highRisk: boolean; checkable: boolean; categories: boolean; independent: boolean; stepsKnown: boolean; irreversible: boolean };

// Each job described by the same questions.
const JOBS: [string, Job][] = [
  ["one-off data clean-up script", { ships: false, highRisk: false, checkable: true, categories: false, independent: false, stepsKnown: false, irreversible: false }],
  ["customer refund assistant", { ships: true, highRisk: true, checkable: true, categories: true, independent: false, stepsKnown: true, irreversible: true }],
  ["weekly market research report", { ships: true, highRisk: false, checkable: false, categories: false, independent: true, stepsKnown: false, irreversible: false }],
  ["checkout feature in an existing app", { ships: true, highRisk: true, checkable: true, categories: false, independent: false, stepsKnown: false, irreversible: false }],
  ["hiring workflow agent", { ships: true, highRisk: true, checkable: false, categories: false, independent: false, stepsKnown: true, irreversible: true }],
];

// How much rigor: follows how long the code lives and what a mistake costs (Module 08c).
function paradigm(j: Job): [string, string[]] {
  if (!j.ships && !j.highRisk) return ["vibe", []];
  if (j.highRisk && j.checkable) return ["spec + test-driven", ["C10"]];
  if (j.highRisk) return ["spec + human review", []];
  return ["intent brief", []];
}

// What shape: follows the structure of the work (Module 07a).
function architecture(j: Job): [string, string[]] {
  let shape: string, cases: string[];
  if (j.categories) [shape, cases] = ["router", []];
  else if (j.independent) [shape, cases] = ["supervisor", ["C11"]];
  else if (j.stepsKnown) [shape, cases] = ["plan-and-execute", ["C13"]];
  else [shape, cases] = ["single agent", ["C12"]];
  if (j.irreversible) [shape, cases] = [shape + " + human gates", [...cases, "C05"]];
  return [shape, cases];
}

for (const [name, job] of JOBS) {
  const [p, pc] = paradigm(job), [a, ac] = architecture(job);
  const cases = [...new Set([...pc, ...ac])].sort();
  console.log(`${name}:`);
  console.log(`    ${p} / ${a}` + (cases.length ? `   (see ${cases.join(", ")})` : ""));
}

import java.util.*;

public class Main {
    record Job(String name, boolean ships, boolean highRisk, boolean checkable, boolean categories, boolean independent, boolean stepsKnown, boolean irreversible) {}
    record Pick(String choice, List<String> cases) {}

    // Each job described by the same questions.
    static final List<Job> JOBS = List.of(
            new Job("one-off data clean-up script", false, false, true, false, false, false, false),
            new Job("customer refund assistant", true, true, true, true, false, true, true),
            new Job("weekly market research report", true, false, false, false, true, false, false),
            new Job("checkout feature in an existing app", true, true, true, false, false, false, false),
            new Job("hiring workflow agent", true, true, false, false, false, true, true));

    // How much rigor: follows how long the code lives and what a mistake costs (Module 08c).
    static Pick paradigm(Job j) {
        if (!j.ships() && !j.highRisk()) return new Pick("vibe", List.of());
        if (j.highRisk() && j.checkable()) return new Pick("spec + test-driven", List.of("C10"));
        if (j.highRisk()) return new Pick("spec + human review", List.of());
        return new Pick("intent brief", List.of());
    }

    // What shape: follows the structure of the work (Module 07a).
    static Pick architecture(Job j) {
        Pick p;
        if (j.categories()) p = new Pick("router", List.of());
        else if (j.independent()) p = new Pick("supervisor", List.of("C11"));
        else if (j.stepsKnown()) p = new Pick("plan-and-execute", List.of("C13"));
        else p = new Pick("single agent", List.of("C12"));
        if (j.irreversible()) {
            List<String> cases = new ArrayList<>(p.cases());
            cases.add("C05");
            p = new Pick(p.choice() + " + human gates", cases);
        }
        return p;
    }

    public static void main(String[] args) {
        for (Job job : JOBS) {
            Pick p = paradigm(job), a = architecture(job);
            TreeSet<String> cases = new TreeSet<>(p.cases());
            cases.addAll(a.cases());
            System.out.println(job.name() + ":");
            System.out.println("    " + p.choice() + " / " + a.choice() + (cases.isEmpty() ? "" : "   (see " + String.join(", ", cases) + ")"));
        }
    }
}