--- title: 'Consulting and Coaching' source: 'https://academia.sh/en/courses/architect-role/consulting-and-coaching' course: "The Architect's Role" language: en updated: '2026-08-23T07:01:03+00:00' license: 'CC BY-SA 4.0' --- # Consulting and Coaching Conveying the same decision as a directive, a written rationale, and by working together: separating the common case from the edge case, measuring the correct-application rate and the cost of conveyance in a two-wave model, and counting which form of conveyance survives a team change. The previous lesson measured the conditions under which a decision is born: the fresher the graph the decision-maker sees, the more feasible the decision. A decision being feasible, though, does not mean it gets applied. The third lesson's oversight measurement showed that decisions lose their counterpart in the code, but it never distinguished how the decision reached the team. The same decision can be conveyed in three separate forms. **Directive**: the rule is announced, no rationale is given. **Written rationale**: the rule is written down together with its threshold and trade-off — this is the form of the decision record established in the Introduction to System Design course. **Working together**: the decision's first implementation is done together with a few developers; the words **architect as consultant** and **coaching** describe this form. This lesson runs all three on the same decision and the same set of cases. ## Common Case and Edge Case The difference between forms of conveyance does not show up in every case the decision applies to. The cases a decision passes through split into two. The **common case** is the one that fits the rule's wording exactly: the rule "front modules do not directly import the data access module" applies directly when an edge to data access is drawn in a front module. This does not require knowing the rationale, knowing the rule is enough. The **edge case** is the one where the rule's wording is not enough: is the batch job module a front, which layer must a daily report query pass through, does a new read path written for the external catalog fall within this rule's scope. These questions can only be answered by knowing **why** the decision was made. In the model, 35% of the cases are edge cases (**WA12**), and the three forms of conveyance diverge only in these cases. The second distinction is time. A decision does not get applied and finish in the week it is made; it keeps being applied months later, by which time the team has changed. The model builds this with two waves: twelve developers in the first wave, four of whom leave before the second wave and are replaced by four people who never received the decision's conveyance at all (**WA13**). ## Measurement Each of the three forms gives the developer a level of understanding and a cost. A directive reaches everyone and is cheap; a written rationale also reaches everyone but has to be read; working together directly touches only three people and is expensive. All the probability and hour values are the model's chosen inputs (**WA14**); what gets measured is the difference under these inputs. The same set of cases and the same sequence of rolls are handed to all three forms, so the comparison is paired. ```js // architecture/conveyance.mjs — the correct-application rate and cost of the same decision in three forms of conveyance // MODEL library network; no real people or teams. Two waves: 4 people leave before the second. function prng(seed) { let s = seed >>> 0; return () => (s = (s * 1664525 + 1013904223) >>> 0) / 2 ** 32; } const PEOPLE = 12, W1 = 8, W2 = 6, EDGE_RATIO = 0.35, DEPARTED = 4; const HOURS = { directive: 2.2, "written rationale": 10.0, "working together": 24.0 }; const DIRECT = { directive: PEOPLE, "written rationale": PEOPLE, "working together": 3 }; const FORMS = Object.keys(HOURS); function runOnce(seed) { const rand = prng(seed); const cases = (people, count) => people.flatMap((p) => Array.from({ length: count }, () => ({ person: p, edge: rand() < EDGE_RATIO, roll: rand() }))); const original = [...Array(PEOPLE).keys()]; const waves = { one: cases(original, W1) }; const readers = Array.from({ length: PEOPLE + DEPARTED }, () => rand() < 0.7); // those who read the rationale const paired = new Set(); while (paired.size < 3) paired.add(Math.floor(rand() * PEOPLE)); // those worked with together const departed = new Set(); while (departed.size < DEPARTED) departed.add(Math.floor(rand() * PEOPLE)); const newHires = Array.from({ length: DEPARTED }, (_, i) => PEOPLE + i); const secondTeam = [...original.filter((p) => !departed.has(p)), ...newHires]; waves.two = cases(secondTeam, W2); const pairedRemaining = [...paired].filter((p) => !departed.has(p)).length; // probability: in the common case, knowing the rule is enough; in the edge case, the rationale has to be understood const P = { directive: (p, edge) => (p >= PEOPLE ? (edge ? 0.10 : 0.30) : edge ? 0.15 : 0.95), "written rationale": (p, edge) => (edge ? (readers[p] ? 0.60 : 0.15) : 0.95), "working together": (p, edge) => (p >= PEOPLE ? (pairedRemaining ? (edge ? 0.50 : 0.95) : edge ? 0.15 : 0.60) : edge ? (paired.has(p) ? 0.95 : 0.50) : 0.95), }; const count = (form, list) => list.filter((d) => d.roll < P[form](d.person, d.edge)).length; return { pairedRemaining, edge1: waves.one.filter((d) => d.edge).length, edge2: waves.two.filter((d) => d.edge).length, n1: waves.one.length, n2: waves.two.length, form: Object.fromEntries(FORMS.map((f) => [f, { d1: count(f, waves.one), d2: count(f, waves.two) }])) }; } const SEED = 5150; const result = runOnce(SEED); const col = (s, n) => String(s).padEnd(n); console.log(`${PEOPLE} developers; first wave ${result.n1} cases (${result.edge1} edge), second wave ${result.n2} cases (${result.edge2} edge)`); console.log(`seed ${SEED}; ${DEPARTED} people left before the second wave, ${result.pairedRemaining}/3 paired people remained\n`); console.log(col("form of conveyance", 22) + col("wave 1", 11) + col("wave 2", 11) + col("total", 17) + col("hours", 8) + "direct people"); console.log("-".repeat(82)); for (const f of FORMS) { const v = result.form[f], t = v.d1 + v.d2; console.log(col(f, 22) + col(`${v.d1}/${result.n1}`, 11) + col(`${v.d2}/${result.n2}`, 11) + col(`${t}/${result.n1 + result.n2} (${((t / (result.n1 + result.n2)) * 100).toFixed(0)}%)`, 17) + col(HOURS[f].toFixed(1), 8) + DIRECT[f]); } console.log("\nincrease over the previous form (this seed):"); for (let i = 1; i < FORMS.length; i++) { const a = result.form[FORMS[i - 1]], b = result.form[FORMS[i]]; const dt = (b.d1 + b.d2) - (a.d1 + a.d2), dh = HOURS[FORMS[i]] - HOURS[FORMS[i - 1]]; console.log(` ${col(FORMS[i], 22)}+${col(dt, 4)}correct +${col(dh.toFixed(1), 6)}hours ${(dt / dh).toFixed(2)} correct per hour`); } // a single seed can be noisy: average over 200 seeds const N = 200; const totals = Object.fromEntries(FORMS.map((f) => [f, { d1: 0, d2: 0 }])); for (let t = 0; t < N; t++) { const k = runOnce(1000 + t * 7); for (const f of FORMS) { totals[f].d1 += k.form[f].d1; totals[f].d2 += k.form[f].d2; } } console.log(`\naverage correct application over ${N} seeds:`); console.log(col("form of conveyance", 22) + col("wave 1", 9) + col("wave 2", 9) + col("total", 9) + "per hour"); console.log("-".repeat(57)); for (const f of FORMS) { const d1 = totals[f].d1 / N, d2 = totals[f].d2 / N; console.log(col(f, 22) + col(d1.toFixed(1), 9) + col(d2.toFixed(1), 9) + col((d1 + d2).toFixed(1), 9) + ((d1 + d2) / HOURS[f]).toFixed(2)); } const avg = (f) => (totals[f].d1 + totals[f].d2) / N; console.log(`\nwave 2 difference: written rationale ${(totals["written rationale"].d2 / N).toFixed(1)}, working together ${(totals["working together"].d2 / N).toFixed(1)}, directive ${(totals.directive.d2 / N).toFixed(1)}`); console.log(`written rationale - directive = ${(avg("written rationale") - avg("directive")).toFixed(1)} correct, +7.8 hours -> ${((avg("written rationale") - avg("directive")) / 7.8).toFixed(2)} per hour`); console.log(`working together - written rationale = ${(avg("working together") - avg("written rationale")).toFixed(1)} correct, +14.0 hours -> ${((avg("working together") - avg("written rationale")) / 14).toFixed(2)} per hour`); ``` ``` 12 developers; first wave 96 cases (27 edge), second wave 72 cases (26 edge) seed 5150; 4 people left before the second wave, 2/3 paired people remained form of conveyance wave 1 wave 2 total hours direct people ---------------------------------------------------------------------------------- directive 71/96 43/72 114/168 (68%) 2.2 12 written rationale 83/96 59/72 142/168 (85%) 10.0 12 working together 84/96 62/72 146/168 (87%) 24.0 3 increase over the previous form (this seed): written rationale +28 correct +7.8 hours 3.59 correct per hour working together +4 correct +14.0 hours 0.29 correct per hour average correct application over 200 seeds: form of conveyance wave 1 wave 2 total per hour --------------------------------------------------------- directive 64.7 37.7 102.4 46.56 written rationale 75.1 56.3 131.4 13.14 working together 80.1 58.9 139.1 5.79 wave 2 difference: written rationale 56.3, working together 58.9, directive 37.7 written rationale - directive = 29.0 correct, +7.8 hours -> 3.71 per hour working together - written rationale = 7.7 correct, +14.0 hours -> 0.55 per hour ``` ## The Difference Between the Three Forms In the single-seed table, the three forms give 68%, 85%, and 87% correct application, in order. Over two hundred seeds, the average totals are 102.4, 131.4, and 139.1. The order is as expected; the real information is in the **shape of the increases**. Going from a directive to a written rationale gains an average of **29 correct applications** and costs 7.8 hours: 3.71 per hour. Going from a written rationale to working together gains **7.7 correct applications** and costs 14 hours: 0.55 per hour. The ratio between the two gains is roughly sevenfold. This does not say coaching is worthless; what it says is that starting with coaching where the rationale has not been written down is the most expensive path. The "per hour" column on the right, though, has to be read in the opposite direction. A directive produces 46.56 correct applications per hour, working together produces 5.79. Average yield is highest for the cheapest form, and this is always true; the cheap one has high yield and a low outcome. Choosing a form of conveyance by looking at average yield means choosing the directive. The decision is made by looking at the **increase**: how many correct applications the next hour brings. ## What Remains When the Team Changes The wave-2 column is this lesson's real finding. In the first wave, the average difference between directive and written rationale is 10.4 correct applications (64.7 against 75.1). In the second wave — that is, after four people leave and are replaced by new hires — the difference rises to **18.6** (37.7 against 56.3). The directive collapses not with time but with **turnover**: even the common case is uncertain in the hands of someone who never heard the announcement. Working together's second-wave value is 58.9, the written rationale's is 56.3 — a difference of 2.6. This difference depends on whether the people worked with together have left or not. In the single-seed run, two of the three had remained; had none remained, the form would have moved closer to the directive. What coaching conveys does not live in a document but in a person, and it can leave together with that person. The one-sentence conclusion for the three forms is this, and all three are tied to a number: a directive is the cheapest conveyance and passes 15% of edge cases correctly; a written rationale is mid-cost, passes more than half of edge cases correctly, and survives a team change; working together gives the highest accuracy, is the most expensive, and its durability depends on the people worked with together staying. ## Summary - Forms of conveyance do not diverge in common cases; the difference comes only from edge cases that require the decision's rationale, and 35% of the cases in the model are edge cases. - On the same 168 cases, the three forms gave 68%, 85%, and 87% correct application; the averages over two hundred seeds came to 102.4, 131.4, and 139.1. - The increases are not equal: going from directive to written rationale brings 3.71 correct applications per hour, going from written rationale to working together brings 0.55 per hour. - Average yield is highest for the cheapest form (directive 46.56, working together 5.79); a form of conveyance is chosen by looking at the increase, not the average yield. - Team change raises the gap between directive and written rationale from 10.4 to 18.6; coaching's gain depends on the people worked with together staying, the written rationale's does not. ## Next Step This topic defined the architect's role and tied every part of it to a number: what a decision is was measured by its cost of reversal, its level by the number of units it covers, its responsibilities by the compliance rate of an unsupervised decision, the cost of being cut off from the code by the stillborn-decision rate, and the form of conveyance by the correct-application rate. In all of these measurements, decisions were taken as a ready-made input. The set of decisions was given, its scope measured, conveyed, and tracked — but the question of **how the decision itself gets made** was never entered. How is a choice made between two conflicting quality attributes; which part of a system's complexity comes from the nature of the work and which was added afterward; how is it known at decision time which decision is reversible; how is a technology choice's exit cost calculated. The next topic moves on to these questions, and the first is the hardest: when two attributes conflict, where do the weights that pick the winner come from, and does the winner change when the weight changes.