5D Library › Scaling Laws, Allometric Growth and the Statistical Physics of Organisational Metabolism · 中文

Chapter 8 Practice and a Pre-Registered Trial

Note

The checklist in this chapter is a thinking tool, not a management standard or investment advice, and it promises no management results. The example is a fictional “Faraway Hills Studio”; all names, numbers and dependencies are invented to demonstrate the calculations and come from no real organisation or client. Any real team’s organisational design must rest on its own data and, where necessary, on advice from qualified professionals.

Part 1 A four-step checklist for scale and organisational metabolism

The models of the first six chapters can be organised into four questions. They help a growing team judge whether size is bringing city-like gains or an organism-like burden of maintenance.

  1. Monitoring the scaling exponents of net output per person and of coordination cost. Plot quarterly headcount, net output (revenue minus direct costs) and administrative and coordination costs (management, administration, internal meetings and coordination tools) on logarithmic axes and fit an exponent to each (Chapters 1 and 3). A net-output exponent below 1 together with a coordination-cost exponent above 1 indicates that size is being swallowed by coordination (the schematic model of Chapter 4).
  2. Splitting project groups and decoupling their interfaces. How should teams be split so that most dependencies stay within teams (near decomposability and “mirroring”, Chapter 6)? How many communication channels are there before and after the split (Chapter 5)?
  3. Spot-checking the decay of information across levels. When a sample of instructions passes from the top to the front line, how much of the key content survives each level (Williamson’s control loss α\alpha, Chapter 6)?
  4. An early warning that maintenance is swallowing the innovation budget. How is the share of working hours spent maintaining products already in service changing? On present trends, in which year will less than 20 % of hours be left for new work (Chapter 2)?

Calculation

The checklist applied to the fictional “Faraway Hills Studio”. Step 1: over 12 quarters headcount rises from 20 to 85, with invented data on net output and coordination costs. Step 2: 30 people (5 product modules × 6 functions) and 40 recurring dependencies (mostly within modules); a split into 6 function teams is compared with a split into 5 module teams. Step 3: an audit traces 20 instructions through three levels and counts how many of 100 key points survive each level (invented counts). Step 4: engineering hours grow by 5 % a year, every feature in service needs 60 hours of maintenance a year, and 30 new features ship each year.

# The four-step checklist applied to a FICTIONAL studio (all names and numbers invented).
import math, random
from statistics import mean
rng = random.Random(36)

def slope(xs, ys):
    lx, ly = [math.log(x) for x in xs], [math.log(y) for y in ys]
    mx, my = mean(lx), mean(ly)
    return (sum((a - mx) * (b - my) for a, b in zip(lx, ly))
            / sum((a - mx) ** 2 for a in lx))

# Step 1: twelve quarters of headcount, net output and coordination cost (invented).
heads = [20, 23, 26, 30, 34, 38, 44, 50, 57, 65, 74, 85]
output = [round(9.0 * n ** 0.92 * math.exp(rng.gauss(0, 0.04)), 1) for n in heads]
coord = [round(0.30 * n ** 1.25 * math.exp(rng.gauss(0, 0.05)), 1) for n in heads]
b_out, b_co = slope(heads, output), slope(heads, coord)
print(f"step 1: exponent of net output {b_out:.2f}, of coordination cost {b_co:.2f}")
print(f"   coordination / net output: {coord[0] / output[0]:.1%} at {heads[0]} people,"
      f" {coord[-1] / output[-1]:.1%} at {heads[-1]}")
print(f"   per-person net output: {output[0] / heads[0]:.2f} ->"
      f" {output[-1] / heads[-1]:.2f}")

# Step 2: 30 people (5 product modules x 6 functions), 40 recurring dependencies between
# pairs of people; split into six function teams or five module teams. Count the
# dependencies that cross team lines, and the communication channels.
items = [(m, k) for m in range(5) for k in range(6)]          # module m, function k
deps = []
while len(deps) < 40:
    a, b = rng.sample(items, 2)
    if a[0] == b[0] or rng.random() < 0.04:            # mostly within one module
        deps.append((a, b))
for lab, team in (("6 function teams", lambda it: it[1]),
                  ("5 module teams", lambda it: it[0])):
    cross = sum(team(a) != team(b) for a, b in deps)
    print(f"step 2: {lab:16s}: {cross:2d} of 40 dependencies cross teams")
print(f"   channels: all 30 together {30 * 29 // 2}; five teams of six plus links"
      f" among the leads {5 * 15 + 10}")

# Step 3: an audit traces 20 instructions from the founder through three levels and
# counts how many of 5 key points survive at each level (invented counts out of 100).
kept = [100, 91, 79, 66]
steps = [b / a for a, b in zip(kept, kept[1:])]
print("step 3: retained per level " + ", ".join(f"{s:.2f}" for s in steps)
      + f"; end to end {kept[-1] / kept[0]:.2f}")

# Step 4: engineering hours grow 5 % a year; every live feature needs 60 hours a year of
# upkeep and the studio ships 30 new features a year (invented). When does upkeep
# leave less than 20 % of hours for new work?
hours, live = 12000.0, 90
for year in range(1, 16):
    hours *= 1.05; live += 30
    share = 60 * live / hours
    if year in (1, 3) or share > 0.8:
        print(f"step 4: year {year:2d}: upkeep takes {share:.0%} of engineering hours")
    if share > 0.8: break
# step 1: exponent of net output 0.91, of coordination cost 1.27
#    coordination / net output: 8.9% at 20 people, 13.3% at 85
#    per-person net output: 6.71 -> 6.44
# step 2: 6 function teams: 39 of 40 dependencies cross teams
# step 2: 5 module teams  :  8 of 40 dependencies cross teams
#    channels: all 30 together 435; five teams of six plus links among the leads 85
# step 3: retained per level 0.91, 0.87, 0.84; end to end 0.66
# step 4: year  1: upkeep takes 57% of engineering hours
# step 4: year  3: upkeep takes 78% of engineering hours
# step 4: year  4: upkeep takes 86% of engineering hours

Step 1: the exponent of net output is 0.91 and that of coordination costs 1.27; coordination costs rise from 8.9 % of net output at 20 people to 13.3 % at 85, and net output per person falls from 6.71 to 6.44. Headcount has more than quadrupled while each person’s net output has fallen, a signal of the “maintenance swallowing supply” of Chapter 2 and of the δ>0\delta > 0 case of Chapter 4. With only 12 points spanning less than an order of magnitude, the confidence intervals of the two exponents are wide; they are warnings, not diagnoses.

Step 2: with teams split by function, 39 of the 40 dependencies cross team boundaries; with teams split by product module, only 8 do. The communication channels fall from 435 among 30 people all connected to each other to 85 for five teams of six plus links among the team leads. Teams should be split according to dependencies, not according to the functions on the organisation chart.

Step 3: the shares retained at each level are 0.91, 0.87 and 0.84, leaving 0.66 after three levels, near the lower end of the fidelity at the optimal number of levels in the Chapter 6 example (0.63). Adding another level without improving how information is passed on would compound the distortion.

Step 4: maintenance already takes 57 % of engineering hours in year 1, 78 % in year 3 and 86 % in year 4, crossing the warning line of “less than 20 % left for new work”. Possible responses include retiring low-value features, lowering the maintenance cost of each feature, or estimating the future maintenance burden of a feature before adding it.

Part 2 A pre-registered randomised controlled trial

Question

When 12 people divide the writing of code by module and must finally pass a hidden integration test suite written in advance, does “three squads of four plus standardised interface documents” (3×6+3=213 \times 6 + 3 = 21 communication channels) complete the task faster than “twelve people in a flat structure communicating freely” (66 channels)?

Evidence

Existing evidence. The experiments of Ringelmann and of Ingham and colleagues in Chapter 5 show that effort per person falls with group size, through both coordination and motivation (Ingham et al. 1974); the LEGO experiment of Staats and colleagues shows that four-person teams use about 45 % more labour in total than two-person teams (with a shorter clock time when person-minutes are divided by team size) (Staats et al. 2012). The matched comparisons of MacCormack and colleagues show that the communication structure of an organisation and the modular structure of its product correspond (MacCormack et al. 2012). But the author found no pre-registered experiment that randomly compared “squads plus interface documents” with “everyone in a flat structure” on the same programming task with completion time as the primary outcome.

Design

Element Specification
Design Two parallel arms, randomised by 12-person group, stratified by site, 1:1 allocation
Participants Adults aged 18 or over with basic programming skills, recruited openly through universities and research institutions, paid a fixed fee plus a completion bonus in line with experimental practice; no recruitment from the author’s community, students or customers (including the clients and employees of the author’s businesses)
Inclusion Passing a screening test: online and alone, three short Python exercises (each implementing one function, with public unit tests), at least two of which pass all their tests within 30 minutes; fluent reading and writing in the task language of the site
Exclusions Failing the screening test; participants in the study’s pilot; anyone who has seen the task’s code base before (for example, by helping to develop it); if members of a group report knowing each other beforehand, the group is re-formed
Baseline covariate Before randomisation, each person solves a warm-up programming exercise of about 10 minutes alone in the laboratory; the mean over the group of the members’ log times
Task The skeleton of a small code base in Python, divided into 3 modules and 12 components (4 per module), with 6 interface functions between modules whose specifications are fixed in advance; members divide the writing of the code by module. Everyone can read the whole code base and run the public unit tests; the integration tests are hidden: a group may submit at any time, the system reports only the number of tests passed and the numbers of the failing interfaces, never the content of the tests, and submissions must be at least 5 minutes apart. Code base, programming environment and overall instructions are the same in both arms
Definition of “complete” A submission passes every hidden integration test; the system records the time of that submission
Communication In both arms, communication is possible only through the system’s logged, structured text chat: messages are organised into channels and direct messages, and a “reply” function can point to a particular message; no voice, video, face-to-face talk or any channel outside the system. The system records the time, sender, audience and text of every message
Arm A (squads + interface documents) Randomly divided into 3 squads of 4, each responsible for one module and allowed to write only to it; each squad has a squad channel; in each squad one liaison is chosen at random, the three liaisons share a liaison channel, and the system blocks all other cross-squad messages; at the start each squad receives a standardised interface specification (the signature, data formats, error handling and an example call for each interface). 21 communication channels in all (pairs of members who can exchange messages)
Arm B (flat) 12 people without squads, with one all-hands channel and direct messages between any two people (66 communication channels); anyone may write to any module; no separate interface specification, though the overall instructions contain the same interface specifications
Blinding Participants know their own arm’s rules but not the hypothesis or the other arm’s rules; completion time and integration-test results are recorded by the system, and the communication measures are computed by programs written in advance; analysts are blind to arm until the analysis plan is locked
Primary outcome Completion time: minutes from the start until every hidden integration test passes; groups that have not passed within 90 minutes are assigned 90 minutes. Analysed on the log scale
Secondary outcomes Rework error rate and the communication measures (defined below)
Sample size Primary plan (90 % power): 75 analysable and 84 recruited groups per arm, 2,016 people. Pre-registered secondary fallback (80 % power): 56 analysable and 63 recruited groups per arm, 1,512 people; for when it applies, see the note “Is the size necessary?”
Analysis Linear regression of log completion time on arm, site and the baseline covariate, reporting the ratio RR of geometric means between arms with its 95 % confidence interval; two-sided α=0.05\alpha = 0.05. Sensitivity analysis: survival analysis treating non-completion as censored

There is a single primary outcome. The secondary outcomes help explain the result (if arm A is faster, is it because there was less communication, more evenly or more narrowly spread communication, or less rework?) but play no part in the primary verdict. All are computed by programs written in advance from the submission and chat logs, over the period from the start to completion (to 90 minutes for groups that do not finish):

  • Rework error rate: the share of the 6 interfaces that fail at the group’s first integration submission; the number of failed submissions before all tests pass is also reported.
  • Number of messages and bytes: the total number of messages sent by the group (each channel message or direct message counted once), and the sum of the UTF-8 byte lengths of their text. A Chinese character usually takes 3 bytes and an English letter 1, so sites with different task languages are not compared directly, and the analysis is stratified by site.
  • Information entropy: if member ii sends a share pip_i of the group’s messages, H=−∑ipilog⁡2piH = -\sum_i p_i \log_2 p_i bits (a member who sends nothing has pi=0p_i = 0, and by convention that term is 0), ranging from 0 (one person sends every message) to log⁡212≈3.58\log_2 12 \approx 3.58 (all 12 send equally many) (Shannon 1948). It measures how evenly speaking is spread among members, not the information content of the messages.
  • Response latency: for every message that someone else answers with the “reply” function, the number of seconds from that message to its first reply; the median within each group. For groups with fewer than 5 replies this measure is recorded as missing.
  • Others: the share of communication messages (chat messages as a share of all logged events: messages, code saves and integration submissions); the number of cross-module messages; the subjective workload of each person.

Sample size

Calculation

# Chapter 8 trial. Part 1: a MODEL of the hypothesis (simulated groups, not data about
# people). Twelve people each write one of 12 components (3 code modules x 4); work time
# per person ~ lognormal, median 20 min. Each person loses 1.2 % of working time for every
# colleague he or she actually messages: 11 in the flat arm; 3 teammates (plus the other
# two liaisons, for liaisons) in the modular arm. Each of the 3 module boundaries fails
# the hidden integration tests with probability 0.35 (flat, no separate interface
# sheet) or 0.15 (modular, with an interface sheet); a failure costs 8 min of rework.
# Integration itself takes 5 min.
# Part 2: sample size for the primary outcome, log completion time of the 12-person group,
# adjusted for a baseline covariate (mean log time of the members' solo warm-up coding
# exercise) that correlates rho with it; adjustment multiplies the variance by 1 - rho^2.
import math, random
from statistics import NormalDist, mean, stdev
rng = random.Random(1975)

def group(modular):
    t = []
    for i in range(12):
        partners = (3 + (2 if i % 4 == 0 else 0)) if modular else 11
        work = 20 * math.exp(rng.gauss(0, 0.3))
        t.append(work / (1 - 0.012 * partners))
    fails = sum(rng.random() < (0.15 if modular else 0.35) for _ in range(3))
    return math.log(max(t) + 5 + 8 * fails), fails

def n_per_arm(sd, ratio, rho=0.0, alpha=0.05, power=0.90):
    z = NormalDist().inv_cdf
    return math.ceil(2 * (z(1 - alpha / 2) + z(power)) ** 2 * sd ** 2 * (1 - rho ** 2)
                     / math.log(ratio) ** 2) + 1

if __name__ == "__main__":
    flat = [group(False) for _ in range(5000)]; mod = [group(True) for _ in range(5000)]
    lf, lm = [x[0] for x in flat], [x[0] for x in mod]
    for lab, arm, logs in (("flat", flat, lf), ("modular", mod, lm)):
        print(f"model, {lab:7s} arm: geometric mean {math.exp(mean(logs)):.1f} min,"
              f" SD of log time {stdev(logs):.2f}, rework {mean(x[1] for x in arm):.2f}")
    gm = math.exp(mean(lm) - mean(lf))
    print(f"model ratio of geometric means (modular / flat): {gm:.2f}")
    print("analysable GROUPS per arm, 90 % power, alpha 0.05:")
    print("   SD of log time   ratio 0.80   ratio 0.85   ratio 0.85 with rho = 0.5")
    for sd in (0.25, 0.35, 0.45):
        print(f"       {sd:.2f}           {n_per_arm(sd, 0.80):4d}         "
              f"{n_per_arm(sd, 0.85):4d}            {n_per_arm(sd, 0.85, 0.5):4d}")
    print("pre-registered plans: SD 0.35, ratio 0.85, rho 0.5, 10 % void groups")
    print("   plan        power   analysable/arm   recruited/arm   people/arm   in all")
    for lab, pw in (("primary", 0.90), ("fallback", 0.80)):
        n = n_per_arm(0.35, 0.85, 0.5, power=pw); rec = math.ceil(n / 0.9)
        print(f"   {lab:9s}   {100 * pw:.0f} %         {n:3d}              {rec:3d}"
              f"          {12 * rec:5,d}    {24 * rec:5,d}")
# model, flat    arm: geometric mean 50.6 min, SD of log time 0.18, rework 1.04
# model, modular arm: geometric mean 42.4 min, SD of log time 0.18, rework 0.45
# model ratio of geometric means (modular / flat): 0.84
# analysable GROUPS per arm, 90 % power, alpha 0.05:
#    SD of log time   ratio 0.80   ratio 0.85   ratio 0.85 with rho = 0.5
#        0.25             28           51              39
#        0.35             53           99              75
#        0.45             87          163             122
# pre-registered plans: SD 0.35, ratio 0.85, rho 0.5, 10 % void groups
#    plan        power   analysable/arm   recruited/arm   people/arm   in all
#    primary     90 %          75               84          1,008    2,016
#    fallback    80 %          56               63            756    1,512

The first part of the program is not data but a model of the hypothesis: each person’s working time is random, each additional colleague actually messaged costs 1.2 % of working time, and each of the three module boundaries has some probability of failing the hidden integration tests and needing rework. In this model the flat arm has a geometric-mean completion time of 50.6 minutes and an average of 1.04 reworks, the squad arm 42.4 minutes and 0.45 reworks, a ratio of 0.84. The standard deviation of log time between groups in the model is only 0.18, because the model ignores many real differences between people and between groups; and the model’s benefits of squads and interface documents are built in by design, whereas real people may not read the documents and liaisons may become bottlenecks.

The sample size is therefore based on much more conservative assumptions: a standard deviation of log completion time between groups of 0.35, a smallest effect of interest of a ratio of geometric means of 0.85 (the squad arm 15 % faster), a correlation of 0.5 between the baseline covariate and the outcome (multiplying the variance by 0.75) and two-sided α=0.05\alpha = 0.05. The primary plan takes 90 % power: 75 analysable groups per arm. Allowing about 10 % of groups to be void because a member is absent or drops out, each arm recruits 84 groups, 1,008 people per arm and 2,016 in all. With a standard deviation of 0.25 or 0.45 the numbers of groups needed would be 39 and 122; without the covariate, 99 at a standard deviation of 0.35. The pre-registered secondary fallback changes only the power, to 80 %, keeping every other assumption: 56 analysable and 63 recruited groups per arm, 756 people per arm and 1,512 in all (the last two lines of the program). All these parameters are assumptions. Before the trial a small pilot is run only to check the difficulty of the task and the working of the hidden tests and the chat system (for example, the share of groups finishing within 90 minutes); it is not used to change the sample size.

Note

Is the size necessary? Under these assumptions the calculation is internally consistent: 2×(1.960+1.282)2×0.352×0.75/(ln⁡0.85)2=73.12 \times (1.960 + 1.282)^2 \times 0.35^2 \times 0.75 / (\ln 0.85)^2 = 73.1, which rounds up and adds 1 to give 75; 75/0.9=83.375 / 0.9 = 83.3, which rounds up to 84. The effect-size assumption is not unduly conservative in itself, since the model above predicts a ratio of 0.84, almost the same as the smallest effect of interest of 0.85; the trial is large mainly because the standard deviation is set at about twice the model’s value and power at 90 %. The author has decided that 90 % power is the primary plan and 80 % power (63 recruited groups per arm, 1,512 people) the pre-registered secondary fallback. Recruitment stops under the fallback only if, by a pre-registered deadline, it has not reached 84 groups per arm but has reached 63; this decision rests on recruitment alone, is taken and recorded by a trial steering committee that has seen no comparison between arms, and the report states under which plan the trial ended. The cost of the fallback is that, when the true effect equals the smallest effect of interest, the probability of some verdict of benefit is about 80 % (80.7 % in the simulation of the decision program below) rather than 90 %. Standby participants are also kept to replace members who fail to turn up, lowering the share of void groups without changing the sample size. The sample size is not reduced on the basis of pilot or interim data.

Note

What “90 % power” means. As in Volume 33, 90 % is the probability of reaching some verdict of benefit (the squad arm is faster) when the true effect exactly equals the smallest effect of interest (R=0.85R = 0.85); in that case the decision rule reaches its strongest verdict, “at least 15 % faster”, only about 2.5 % of the time. The decision program below confirms this by simulation.

Note

Why the group is the unit. The work of the 12 people in a group is interdependent, and the outcome (completion time) is itself a property of the group, so both randomisation and analysis are by group and the sample size is counted in groups; with one outcome value per group, no intraclass correlation or design effect is needed.

Decision rule

Calculation

# Decision rule for the Chapter 8 trial, fixed before any data are collected. R = ratio of
# geometric-mean completion times, modular arm / flat arm, from the pre-specified model
# (log time ~ arm + site + baseline covariate), with its 95 % CI; R < 1 = modular faster.
# Smallest effect of interest: R = 0.85 (15 % faster). Gates: more than 20 % of randomised
# groups void, or the modular structure kept in fewer than 90 % of modular groups
# (fidelity: no talk outside the logged text channels) -> NOT INTERPRETABLE.
import math, random
from statistics import NormalDist, mean
SESOI = 0.85

def verdict(r, lo, hi, void=0.08, fidelity=0.95):
    if void > 0.20:
        return f"R = {r:.2f}: NOT INTERPRETABLE - {void:.0%} of groups void (limit 20 %)"
    if fidelity < 0.90:
        return f"R = {r:.2f}: NOT INTERPRETABLE - structure kept in only {fidelity:.0%}"
    if hi <= SESOI:   v = "modular is at least 15 % faster"
    elif hi < 1:      v = "modular is faster; 15 % not shown"
    elif lo > 1:      v = "modular is SLOWER"
    elif lo >= SESOI and hi <= 1 / SESOI: v = "no difference worth acting on"
    else:             v = "unclear: the interval is too wide to decide"
    return f"R = {r:.2f} ({lo:.2f} to {hi:.2f}): {v}"

def label(lo, hi):
    return verdict(1, lo, hi).split(": ", 1)[1]

if __name__ == "__main__":
    for case in ((0.72, 0.66, 0.79), (0.86, 0.79, 0.94), (0.99, 0.91, 1.08),
                 (1.12, 1.03, 1.22), (0.90, 0.76, 1.07), (0.80, 0.73, 0.88, 0.24),
                 (0.78, 0.71, 0.86, 0.06, 0.81)):
        print(verdict(*case))
    # How often does each verdict occur? 75 analysable groups per arm (primary plan) or
    # 56 (80 % power fallback), residual SD of log time 0.35 x sqrt(1 - 0.5^2).
    rng = random.Random(33); z = NormalDist().inv_cdf(0.975); sd = 0.35 * math.sqrt(0.75)
    for n, true in ((75, 0.85), (75, 0.75), (56, 0.85)):
        tally = {}
        for _ in range(10000):
            a = [rng.gauss(math.log(true), sd) for _ in range(n)]
            b = [rng.gauss(0.0, sd) for _ in range(n)]
            ma, mb = mean(a), mean(b)
            ss = sum((x - ma) ** 2 for x in a) + sum((x - mb) ** 2 for x in b)
            d, se = ma - mb, math.sqrt(ss / (2 * n - 2) * (2 / n))
            v = label(math.exp(d - z * se), math.exp(d + z * se))
            tally[v] = tally.get(v, 0) + 1
        print(f"{n} groups per arm, true R = {true:.2f},"
              " share of 10,000 simulated trials:")
        for k, c in sorted(tally.items(), key=lambda kv: -kv[1]):
            print(f"   {c / 100:5.1f} %  {k}")
# R = 0.72 (0.66 to 0.79): modular is at least 15 % faster
# R = 0.86 (0.79 to 0.94): modular is faster; 15 % not shown
# R = 0.99 (0.91 to 1.08): no difference worth acting on
# R = 1.12 (1.03 to 1.22): modular is SLOWER
# R = 0.90 (0.76 to 1.07): unclear: the interval is too wide to decide
# R = 0.80: NOT INTERPRETABLE - 24% of groups void (limit 20 %)
# R = 0.78: NOT INTERPRETABLE - structure kept in only 81%
# 75 groups per arm, true R = 0.85, share of 10,000 simulated trials:
#     87.9 %  modular is faster; 15 % not shown
#      6.8 %  unclear: the interval is too wide to decide
#      2.6 %  no difference worth acting on
#      2.6 %  modular is at least 15 % faster
# 75 groups per arm, true R = 0.75, share of 10,000 simulated trials:
#     71.2 %  modular is at least 15 % faster
#     28.8 %  modular is faster; 15 % not shown
# 56 groups per arm, true R = 0.85, share of 10,000 simulated trials:
#     77.9 %  modular is faster; 15 % not shown
#     16.8 %  unclear: the interval is too wide to decide
#      2.8 %  modular is at least 15 % faster
#      2.5 %  no difference worth acting on

The first seven example results are invented. If more than 20 % of randomised groups are void, or more than 10 % of the groups in arm A did not operate in the prescribed structure (for example, members talked outside the logged system), the report states “not interpretable” whatever the result. Only if the upper limit of the 95 % confidence interval of RR does not exceed 0.85 does the report state “the squad arm is at least 15 % faster”. The simulation shows that under the primary plan (75 groups per arm), if the true RR is exactly 0.85, then of 10,000 simulated trials 87.9 % reach “faster, but 15 % not shown” and 2.6 % the strongest verdict, about 90 % together; if the true RR is 0.75, 71.2 % reach the strongest verdict. If the trial ends under the fallback (56 groups per arm) and the true RR is 0.85, the two shares are 77.9 % and 2.8 %, about 81 % together. Rework error rate and the communication measures are reported only as estimates with intervals and are never used to overturn the primary verdict.

What this trial cannot show

First, arm A changes three things at once: the squad structure, the liaisons and the interface documents. A positive result cannot say which of them worked; testing the “interface-document hypothesis” of Chapter 5 would need a third arm with “squads only, no documents”. Second, the code base is deliberately designed to decompose cleanly into three modules with interfaces fixed in advance, which favours arm A; on tasks whose module boundaries are unclear and whose interfaces must be negotiated along the way, the conclusion might be reversed. Third, this is a small 90-minute programming task performed by 12 strangers, whereas real software teams share a history, long-term incentives and informal relationships, and their code bases and organisations are much larger; the conclusions cannot be extrapolated directly to organisations of hundreds of people. Fourth, both arms can communicate only by logged text chat. This makes it possible to record everything and to enforce the 21 and 66 channels, but it changes the position of the flat arm: the quick interruptions, tone, gestures and overhearing of face-to-face or voice exchange are removed, and twelve people coordinating in text channels spend time simply reading and typing. Experiments have found that groups communicating by computer text complete less work in the same time than face-to-face groups, with the gap larger on tasks that demand more coordination (Straus and McGrath 1994). The conclusions therefore hold only under “text-only communication”: even if the squad arm is faster, that would not show that squads are faster in teams that can talk face to face or by voice, and the restriction probably favours arm A. The shared code base is itself an implicit channel of communication (both arms can read all the code); the figures 21 and 66 count only the pairs who can exchange chat messages. Fifth, participants must pass a programming screen and are likely to be mostly students of computing and related subjects, not professional software teams. Sixth, the 90-minute limit assigns 90 minutes to groups that do not finish; if many do not finish, the primary outcome is compressed, which is why a survival analysis is pre-specified as a sensitivity analysis.

Ethics and conflicts of interest

This is a low-risk study: the task is programming, involves no health intervention and collects no health information, and the only foreseeable discomfort is frustration under time pressure. Even so, the trial must be reviewed and approved by an independent ethics committee, every participant must give informed consent, and the protocol and analysis plan must be registered before the first group is enrolled (Nosek et al. 2018). The instructions state the rules and payments truthfully; not disclosing the hypothesis is withholding of information, not deception, and the purpose of the study is explained to everyone at the end of the session. Anyone may withdraw at any time without giving a reason and is paid for the part completed. Chat logs and code are stored anonymously, used only to compute the pre-specified measures and put to no commercial use. The results will be published whether positive or negative.

Disclosure

The author uses the works of 5D Library, including this book, as the methodological basis of his community courses, the 5D Ascension Cards (Dimensional Shift Card Decks) and the Yafu AI knowledge base, and therefore has a commercial interest in the subject of this book. The author also founded and runs Yafu Global and Asia Influencer X, whose business involves the organisational growth and management of firms and teams, and therefore has a direct commercial interest in the subject of this book. The book discusses mathematical models of biological allometry and of the size of cities and firms; it promotes no course, card deck or service, is not investment advice, promises no results for the management of any business, and uses no client or employee data from these businesses; the Chapter 8 trial is designed to be run and analysed by researchers independent of the author’s business and does not recruit from the author’s community, students or customers, including the clients and employees of these businesses; all the code and the study protocol are published openly for anyone to check.

References

Ingham, Alan G., George Levinger, James Graves, and Vaughn Peckham. 1974. “The Ringelmann Effect: Studies of Group Size and Group Performance.” Journal of Experimental Social Psychology 10 (4): 371–84. https://doi.org/10.1016/0022-1031(74)90033-X.
MacCormack, Alan, Carliss Baldwin, and John Rusnak. 2012. “Exploring the Duality Between Product and Organizational Architectures: A Test of the ‘Mirroring’ Hypothesis.” Research Policy 41 (8): 1309–24. https://doi.org/10.1016/j.respol.2012.04.011.
Nosek, Brian A., Charles R. Ebersole, Alexander C. DeHaven, and David T. Mellor. 2018. “The Preregistration Revolution.” Proceedings of the National Academy of Sciences of the USA 115 (11): 2600–2606. https://doi.org/10.1073/pnas.1708274114.
Shannon, Claude E. 1948. “A Mathematical Theory of Communication.” Bell System Technical Journal 27 (3): 379–423. https://doi.org/10.1002/j.1538-7305.1948.tb01338.x.
Staats, Bradley R., Katherine L. Milkman, and Craig R. Fox. 2012. “The Team Scaling Fallacy: Underestimating the Declining Efficiency of Larger Teams.” Organizational Behavior and Human Decision Processes 118 (2): 132–42. https://doi.org/10.1016/j.obhdp.2012.03.002.
Straus, Susan G., and Joseph E. McGrath. 1994. “Does the Medium Matter? The Interaction of Task Type and Technology on Group Performance and Member Reactions.” Journal of Applied Psychology 79 (1): 87–97. https://doi.org/10.1037/0021-9010.79.1.87.

Fan, Y. (2026). Scaling Laws, Allometric Growth and the Statistical Physics of Organisational Metabolism: From Kleiber's Three-Quarter Power Law and Fractal Supply Networks to the Mortality of Firms, Read Beside Classical Chinese Organisational Thought [规模法则、异速生长与组织新陈代谢的统计物理] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.23788553 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).