https://kanywst.github.io/hammurabi/ Engineering laws, each with its counter-force. en https://kanywst.github.io/hammurabi/laws/psychological-safety/ https://kanywst.github.io/hammurabi/laws/psychological-safety/ A team learns when its members admit mistakes, ask for help and disagree, and they do that far more readily when they believe it is safe to. https://kanywst.github.io/hammurabi/laws/twymans-law/ https://kanywst.github.io/hammurabi/laws/twymans-law/ When real effects that large are rare, a metric that moves surprisingly far is more often a bug in the measurement or the analysis than a real effect. https://kanywst.github.io/hammurabi/laws/mcnamara-fallacy/ https://kanywst.github.io/hammurabi/laws/mcnamara-fallacy/ Decisions drift toward whatever can be counted, until what cannot be counted is treated as if it did not exist. https://kanywst.github.io/hammurabi/laws/makers-schedule/ https://kanywst.github.io/hammurabi/laws/makers-schedule/ People who make things need long unbroken blocks of time, and a calendar run in one-hour slots breaks those blocks into pieces too small to use. https://kanywst.github.io/hammurabi/laws/kingmans-formula/ https://kanywst.github.io/hammurabi/laws/kingmans-formula/ As a server's utilization approaches 100%, the time work spends waiting for it climbs steeply, and variability in arrivals and service multiplies the climb. https://kanywst.github.io/hammurabi/laws/most-ideas-fail/ https://kanywst.github.io/hammurabi/laws/most-ideas-fail/ In online controlled experiments at large web companies, most ideas that survived the team's own pruning do nothing or make things worse once they are measured, and experts tend to be poor at telling in advance which ones. https://kanywst.github.io/hammurabi/laws/wicked-problems/ https://kanywst.github.io/hammurabi/laws/wicked-problems/ For some problems, working out what the problem is and choosing a solution are the same act, so the requirements cannot be settled before the design starts and there is no point at which the problem is done. https://kanywst.github.io/hammurabi/laws/pre-mortem/ https://kanywst.github.io/hammurabi/laws/pre-mortem/ People who doubt a plan the team has already committed to tend to keep quiet; asking them to explain a failure that has already happened draws the doubts out. https://kanywst.github.io/hammurabi/laws/last-responsible-moment/ https://kanywst.github.io/hammurabi/laws/last-responsible-moment/ Commit too early and a guess hardens into the design; wait too long and an option quietly expires, so the decision gets made by default without anyone making it. https://kanywst.github.io/hammurabi/laws/cost-of-delay/ https://kanywst.github.io/hammurabi/laws/cost-of-delay/ Work gets ordered by size, by gut feel or by whoever asks loudest, while what each item loses every week it waits goes uncounted, so the most valuable work often waits behind the merely visible. https://kanywst.github.io/hammurabi/laws/lethal-trifecta/ https://kanywst.github.io/hammurabi/laws/lethal-trifecta/ An AI agent that can read private data, takes in content from outside and can send data out can be steered into leaking that data by whoever wrote the content. https://kanywst.github.io/hammurabi/laws/test-oracle-problem/ https://kanywst.github.io/hammurabi/laws/test-oracle-problem/ A test can only catch a wrong answer if something independent of the code knows the right one, and for many programs nothing does. https://kanywst.github.io/hammurabi/laws/programming-as-theory-building/ https://kanywst.github.io/hammurabi/laws/programming-as-theory-building/ A program's design lives in the heads of the people who built it, and the code and documents carry only part of it, so once those people are gone, changes tend to erode the design even with full documentation in hand. https://kanywst.github.io/hammurabi/laws/small-changes/ https://kanywst.github.io/hammurabi/laws/small-changes/ The larger a change sent for review, the less closely each line is read: defects slip through and the change waits longer for a first look. https://kanywst.github.io/hammurabi/laws/automation-bias/ https://kanywst.github.io/hammurabi/laws/automation-bias/ People working with an automated aid tend to let it stand in for their own checking: they miss what it fails to flag and follow it when it is wrong. https://kanywst.github.io/hammurabi/laws/brandolinis-law/ https://kanywst.github.io/hammurabi/laws/brandolinis-law/ Refuting a false claim takes far more effort than making it, so a stream of cheap claims can swamp the people who have to check them. https://kanywst.github.io/hammurabi/laws/braintrust/ https://kanywst.github.io/hammurabi/laws/braintrust/ Feedback from people who can overrule the owner gets defended against rather than used; peers with no power to impose a fix can be candid, and the owner can afford to hear them. https://kanywst.github.io/hammurabi/laws/believability-weighted-decisions/ https://kanywst.github.io/hammurabi/laws/believability-weighted-decisions/ When a group counts every opinion the same, or defers to rank, the people who have actually done the thing before are outvoted by those who have not. https://kanywst.github.io/hammurabi/laws/genchi-genbutsu/ https://kanywst.github.io/hammurabi/laws/genchi-genbutsu/ Decisions made from reports drift away from what is actually happening, because each layer of summary drops the detail that did not fit its form. https://kanywst.github.io/hammurabi/laws/one-version-rule/ https://kanywst.github.io/hammurabi/laws/one-version-rule/ When consumers may choose which version of a shared dependency to use, each choice becomes a conflict for someone who never made it. https://kanywst.github.io/hammurabi/laws/narratives-not-slides/ https://kanywst.github.io/hammurabi/laws/narratives-not-slides/ An argument cut down to slides and bullets loses the links between its points, so the gaps and warnings that prose would have exposed pass through the review unnoticed. https://kanywst.github.io/hammurabi/laws/pesticide-paradox/ https://kanywst.github.io/hammurabi/laws/pesticide-paradox/ Every way of finding bugs leaves behind the bugs it cannot find, so a test suite that never changes finds fewer and fewer. https://kanywst.github.io/hammurabi/laws/bus-factor/ https://kanywst.github.io/hammurabi/laws/bus-factor/ The fewer people who can keep a system running, the more its future depends on each of them staying. https://kanywst.github.io/hammurabi/laws/lehmans-laws/ https://kanywst.github.io/hammurabi/laws/lehmans-laws/ A program in real use must keep changing or grow less useful, and each change makes it more complex unless work is spent to simplify it. https://kanywst.github.io/hammurabi/laws/technical-debt/ https://kanywst.github.io/hammurabi/laws/technical-debt/ Code shipped before the team fully understands the problem charges extra on later changes to that code until someone rewrites it. https://kanywst.github.io/hammurabi/laws/choose-boring-technology/ https://kanywst.github.io/hammurabi/laws/choose-boring-technology/ Every unfamiliar technology a team adopts brings unknown failure modes and a permanent operating cost, and a team can afford only a few of them. https://kanywst.github.io/hammurabi/laws/strangler-fig/ https://kanywst.github.io/hammurabi/laws/strangler-fig/ Replacing a live system piece by piece around its edges is usually safer than replacing it all at once. https://kanywst.github.io/hammurabi/laws/fixed-time-variable-scope/ https://kanywst.github.io/hammurabi/laws/fixed-time-variable-scope/ When scope is fixed and time is not, the date slips and the scope stays; fixing the time instead forces a choice about what matters. https://kanywst.github.io/hammurabi/laws/churn-rule/ https://kanywst.github.io/hammurabi/laws/churn-rule/ When the team that changes shared infrastructure can push the migration onto its users, the cost of the change multiplies by the number of users. https://kanywst.github.io/hammurabi/laws/beyonce-rule/ https://kanywst.github.io/hammurabi/laws/beyonce-rule/ In a shared codebase, the behavior no test checks is the behavior that changes without warning. https://kanywst.github.io/hammurabi/laws/code-health-standard/ https://kanywst.github.io/hammurabi/laws/code-health-standard/ Holding every change to a standard of perfection makes review slow, and slow review leaves the codebase worse, not better. https://kanywst.github.io/hammurabi/laws/context-not-control/ https://kanywst.github.io/hammurabi/laws/context-not-control/ As an organization grows, rules and approvals tend to scale worse than shared understanding; Netflix's argument is that people given the reasons behind a goal make better local decisions than people given a procedure. https://kanywst.github.io/hammurabi/laws/chaos-engineering/ https://kanywst.github.io/hammurabi/laws/chaos-engineering/ Resilience that has never been exercised is a hypothesis, and production will test it whether or not you schedule the test. https://kanywst.github.io/hammurabi/laws/five-whys/ https://kanywst.github.io/hammurabi/laws/five-whys/ The first answer to "why did this fail" is usually a symptom, and fixing a symptom leaves the cause in place to fail again. https://kanywst.github.io/hammurabi/laws/andon/ https://kanywst.github.io/hammurabi/laws/andon/ Letting anyone who sees an abnormality stop the line keeps a defect from traveling downstream, where it costs more to find and fix. https://kanywst.github.io/hammurabi/laws/mechanisms-not-good-intentions/ https://kanywst.github.io/hammurabi/laws/mechanisms-not-good-intentions/ Asking people to try harder after a failure changes little, because the failure happened to people who were already trying. https://kanywst.github.io/hammurabi/laws/constant-work/ https://kanywst.github.io/hammurabi/laws/constant-work/ A system whose work grows with the number of changes or failures does the most work exactly when it has the least headroom. https://kanywst.github.io/hammurabi/laws/avoid-fallback/ https://kanywst.github.io/hammurabi/laws/avoid-fallback/ A fallback path runs only after something has already failed, so the least-tested code in the system runs under the worst conditions. https://kanywst.github.io/hammurabi/laws/static-stability/ https://kanywst.github.io/hammurabi/laws/static-stability/ A system that has to take new action to survive a failure depends on that action succeeding at the moment things are going wrong. https://kanywst.github.io/hammurabi/laws/you-build-it-you-run-it/ https://kanywst.github.io/hammurabi/laws/you-build-it-you-run-it/ When the team that writes a service also operates it, the cost of every operational weakness lands on the people who can fix it. https://kanywst.github.io/hammurabi/laws/disagree-and-commit/ https://kanywst.github.io/hammurabi/laws/disagree-and-commit/ Waiting for everyone to agree is often slower than committing and correcting course if the call turns out wrong. https://kanywst.github.io/hammurabi/laws/working-backwards/ https://kanywst.github.io/hammurabi/laws/working-backwards/ Teams that start from a solution often build things no customer needed; starting from the announcement exposes that early. https://kanywst.github.io/hammurabi/laws/blameless-postmortem/ https://kanywst.github.io/hammurabi/laws/blameless-postmortem/ Punishing the person nearest a failure teaches people to hide what they did. https://kanywst.github.io/hammurabi/laws/toil/ https://kanywst.github.io/hammurabi/laws/toil/ Manual, repetitive operational work grows with the service and, left unchecked, crowds out engineering. https://kanywst.github.io/hammurabi/laws/error-budget/ https://kanywst.github.io/hammurabi/laws/error-budget/ An SLO below 100% leaves a measurable allowance of failure, and that allowance can be spent. https://kanywst.github.io/hammurabi/laws/shirky-principle/ https://kanywst.github.io/hammurabi/laws/shirky-principle/ Institutions tend to keep alive the problem they exist to solve. https://kanywst.github.io/hammurabi/laws/ringelmann-effect/ https://kanywst.github.io/hammurabi/laws/ringelmann-effect/ Each person contributes less as a group grows, most of all when no one can see who did what. https://kanywst.github.io/hammurabi/laws/metcalfes-law/ https://kanywst.github.io/hammurabi/laws/metcalfes-law/ Each new node adds value to every existing one, so a network's value outgrows its size. https://kanywst.github.io/hammurabi/laws/the-bitter-lesson/ https://kanywst.github.io/hammurabi/laws/the-bitter-lesson/ In AI, general methods that scale with compute have, in the long run, beaten hand-coded human knowledge. https://kanywst.github.io/hammurabi/laws/amaras-law/ https://kanywst.github.io/hammurabi/laws/amaras-law/ New technology is overrated in its first years and underrated over a decade. https://kanywst.github.io/hammurabi/laws/moores-law/ https://kanywst.github.io/hammurabi/laws/moores-law/ The number of transistors on a chip at lowest cost per part doubles about every two years. https://kanywst.github.io/hammurabi/laws/second-system-effect/ https://kanywst.github.io/hammurabi/laws/second-system-effect/ After a first success, designers tend to pack the ideas they deferred into the second system. https://kanywst.github.io/hammurabi/laws/principle-of-least-astonishment/ https://kanywst.github.io/hammurabi/laws/principle-of-least-astonishment/ Behavior that surprises users costs more than behavior that is slightly worse but expected. https://kanywst.github.io/hammurabi/laws/single-responsibility-principle/ https://kanywst.github.io/hammurabi/laws/single-responsibility-principle/ A module serving two groups gets conflicting change requests from both. https://kanywst.github.io/hammurabi/laws/occams-razor/ https://kanywst.github.io/hammurabi/laws/occams-razor/ The explanation that needs the fewest unverified assumptions is usually the right one. https://kanywst.github.io/hammurabi/laws/theory-of-constraints/ https://kanywst.github.io/hammurabi/laws/theory-of-constraints/ A system's throughput is set by its single tightest bottleneck. https://kanywst.github.io/hammurabi/laws/dry-principle/ https://kanywst.github.io/hammurabi/laws/dry-principle/ Knowledge kept in two places drifts apart, because nothing makes the copies change together. https://kanywst.github.io/hammurabi/laws/kiss-principle/ https://kanywst.github.io/hammurabi/laws/kiss-principle/ A system has to be simple enough for an ordinary person to fix under bad conditions. https://kanywst.github.io/hammurabi/laws/yagni/ https://kanywst.github.io/hammurabi/laws/yagni/ Code built for imagined future needs costs time now and rarely fits the need that arrives. https://kanywst.github.io/hammurabi/laws/broken-windows-theory/ https://kanywst.github.io/hammurabi/laws/broken-windows-theory/ Visible disorder left unrepaired can signal that standards are optional, inviting more. https://kanywst.github.io/hammurabi/laws/normal-accident-theory/ https://kanywst.github.io/hammurabi/laws/normal-accident-theory/ In complex, tightly coupled systems, accidents are built into the structure. https://kanywst.github.io/hammurabi/laws/jevons-paradox/ https://kanywst.github.io/hammurabi/laws/jevons-paradox/ Making a resource cheaper to use can increase how much of it is used in total. https://kanywst.github.io/hammurabi/laws/law-of-demeter/ https://kanywst.github.io/hammurabi/laws/law-of-demeter/ Code that reaches through other objects' internals breaks when anything in the chain changes. https://kanywst.github.io/hammurabi/laws/ashbys-law/ https://kanywst.github.io/hammurabi/laws/ashbys-law/ A controller can only handle a system if it can respond to as many states as the system has. https://kanywst.github.io/hammurabi/laws/tail-at-scale/ https://kanywst.github.io/hammurabi/laws/tail-at-scale/ When one request fans out to many servers, the slowest one sets the response time. https://kanywst.github.io/hammurabi/laws/gustafsons-law/ https://kanywst.github.io/hammurabi/laws/gustafsons-law/ When the problem grows with the machine, parallel speedup keeps growing nearly linearly. https://kanywst.github.io/hammurabi/laws/kerckhoffs-principle/ https://kanywst.github.io/hammurabi/laws/kerckhoffs-principle/ A system that is secure only while its design stays secret is not secure. https://kanywst.github.io/hammurabi/laws/principle-of-least-privilege/ https://kanywst.github.io/hammurabi/laws/principle-of-least-privilege/ Every permission a component doesn't need widens the damage when something goes wrong. https://kanywst.github.io/hammurabi/laws/ironies-of-automation/ https://kanywst.github.io/hammurabi/laws/ironies-of-automation/ Automation leaves people only the hardest cases, after their skills have faded from disuse. https://kanywst.github.io/hammurabi/laws/fallacies-of-distributed-computing/ https://kanywst.github.io/hammurabi/laws/fallacies-of-distributed-computing/ Networked code quietly assumes eight things about the network that are false in production. https://kanywst.github.io/hammurabi/laws/millers-law/ https://kanywst.github.io/hammurabi/laws/millers-law/ Working memory holds only a handful of chunks (Miller said about seven; later estimates are lower). https://kanywst.github.io/hammurabi/laws/fitts-law/ https://kanywst.github.io/hammurabi/laws/fitts-law/ Small, distant targets take longer to hit and get missed more often. https://kanywst.github.io/hammurabi/laws/hicks-law/ https://kanywst.github.io/hammurabi/laws/hicks-law/ The more options people are given, the longer they take to choose one. https://kanywst.github.io/hammurabi/laws/eaglesons-law/ https://kanywst.github.io/hammurabi/laws/eaglesons-law/ Your own code that you haven't read in six months might as well be someone else's. https://kanywst.github.io/hammurabi/laws/ninety-ninety-rule/ https://kanywst.github.io/hammurabi/laws/ninety-ninety-rule/ The last 10% of the work tends to take as long as the first 90% did. https://kanywst.github.io/hammurabi/laws/wirths-law/ https://kanywst.github.io/hammurabi/laws/wirths-law/ Software gets slower faster than hardware gets faster. https://kanywst.github.io/hammurabi/laws/parkinsons-law/ https://kanywst.github.io/hammurabi/laws/parkinsons-law/ Work expands to fill the time available for it. https://kanywst.github.io/hammurabi/laws/peter-principle/ https://kanywst.github.io/hammurabi/laws/peter-principle/ People tend to get promoted until they reach a role they are bad at, and stay there. https://kanywst.github.io/hammurabi/laws/two-generals-problem/ https://kanywst.github.io/hammurabi/laws/two-generals-problem/ Over an unreliable channel, two parties can never be certain they have agreed. https://kanywst.github.io/hammurabi/laws/littles-law/ https://kanywst.github.io/hammurabi/laws/littles-law/ In a stable system, the average number of items inside equals arrival rate times average time spent. https://kanywst.github.io/hammurabi/laws/cap-theorem/ https://kanywst.github.io/hammurabi/laws/cap-theorem/ During a network partition, a data store must give up either consistency or availability. https://kanywst.github.io/hammurabi/laws/linus-law/ https://kanywst.github.io/hammurabi/laws/linus-law/ A bug that stumps one person is often obvious to someone else looking at the same code. https://kanywst.github.io/hammurabi/laws/premature-optimization/ https://kanywst.github.io/hammurabi/laws/premature-optimization/ Optimizing before measuring spends effort on code that isn't the bottleneck. https://kanywst.github.io/hammurabi/laws/swiss-cheese-model/ https://kanywst.github.io/hammurabi/laws/swiss-cheese-model/ Every safeguard has holes; accidents happen when the holes in several layers line up. https://kanywst.github.io/hammurabi/laws/curse-of-knowledge/ https://kanywst.github.io/hammurabi/laws/curse-of-knowledge/ Once you know something, you can't easily imagine what it's like not to know it. https://kanywst.github.io/hammurabi/laws/dunning-kruger-effect/ https://kanywst.github.io/hammurabi/laws/dunning-kruger-effect/ People who are least skilled at something tend to overrate their ability the most. https://kanywst.github.io/hammurabi/laws/teslers-law/ https://kanywst.github.io/hammurabi/laws/teslers-law/ A system's inherent complexity can't be removed, only moved to someone else. https://kanywst.github.io/hammurabi/laws/boy-scout-rule/ https://kanywst.github.io/hammurabi/laws/boy-scout-rule/ Code decays because cleanup tends to be deferred to a refactor that rarely happens. https://kanywst.github.io/hammurabi/laws/murphys-law/ https://kanywst.github.io/hammurabi/laws/murphys-law/ Given enough time and traffic, a failure mode that can happen eventually will. https://kanywst.github.io/hammurabi/laws/bystander-effect/ https://kanywst.github.io/hammurabi/laws/bystander-effect/ The more people who see a problem, the less likely any one of them is to act on it. https://kanywst.github.io/hammurabi/laws/cunninghams-law/ https://kanywst.github.io/hammurabi/laws/cunninghams-law/ People are quicker to correct a wrong answer than to answer a question. https://kanywst.github.io/hammurabi/laws/worse-is-better/ https://kanywst.github.io/hammurabi/laws/worse-is-better/ A simpler design that is easy to build and adopt tends to beat a more correct but complex one. https://kanywst.github.io/hammurabi/laws/dunbars-number/ https://kanywst.github.io/hammurabi/laws/dunbars-number/ People keep only about 150 stable relationships. Engineers extrapolate: past shared context, added headcount goes to coordination. https://kanywst.github.io/hammurabi/laws/cobra-effect/ https://kanywst.github.io/hammurabi/laws/cobra-effect/ An incentive meant to reduce a problem rewards people for producing more of it. https://kanywst.github.io/hammurabi/laws/kernighans-law/ https://kanywst.github.io/hammurabi/laws/kernighans-law/ Debugging is harder than writing, so code written at your cleverest is beyond your debugging. https://kanywst.github.io/hammurabi/laws/survivorship-bias/ https://kanywst.github.io/hammurabi/laws/survivorship-bias/ Conclusions drawn only from successes ignore the failures that used the same strategy. https://kanywst.github.io/hammurabi/laws/pareto-principle/ https://kanywst.github.io/hammurabi/laws/pareto-principle/ Most of the effect comes from a small share of the causes, such as bugs in a few modules. https://kanywst.github.io/hammurabi/laws/leaky-abstractions/ https://kanywst.github.io/hammurabi/laws/leaky-abstractions/ Every non-trivial abstraction eventually exposes the details it was meant to hide. https://kanywst.github.io/hammurabi/laws/amdahls-law/ https://kanywst.github.io/hammurabi/laws/amdahls-law/ Speeding up one part of a system barely helps when the bottleneck is somewhere else. https://kanywst.github.io/hammurabi/laws/cargo-cult-engineering/ https://kanywst.github.io/hammurabi/laws/cargo-cult-engineering/ Teams copy another company's practices without the conditions that made them work. https://kanywst.github.io/hammurabi/laws/sunk-cost-fallacy/ https://kanywst.github.io/hammurabi/laws/sunk-cost-fallacy/ Teams keep funding a failing project because of what they have already spent on it. https://kanywst.github.io/hammurabi/laws/lindy-effect/ https://kanywst.github.io/hammurabi/laws/lindy-effect/ For ideas and software, the longer something has survived, the longer it is likely to last. https://kanywst.github.io/hammurabi/laws/goodharts-law/ https://kanywst.github.io/hammurabi/laws/goodharts-law/ A number stops measuring well once people are rewarded for moving it. https://kanywst.github.io/hammurabi/laws/hofstadters-law/ https://kanywst.github.io/hammurabi/laws/hofstadters-law/ Work takes longer than estimated, even when the estimate already allows for that. https://kanywst.github.io/hammurabi/laws/hanlons-razor/ https://kanywst.github.io/hammurabi/laws/hanlons-razor/ People read malice into delays and bugs that are better explained by fatigue or missing context. https://kanywst.github.io/hammurabi/laws/postels-law/ https://kanywst.github.io/hammurabi/laws/postels-law/ Systems that assume every peer follows the spec exactly tend to be brittle against the first one that doesn't. https://kanywst.github.io/hammurabi/laws/xy-problem/ https://kanywst.github.io/hammurabi/laws/xy-problem/ People ask for help with their attempted fix instead of the problem they actually have. https://kanywst.github.io/hammurabi/laws/brooks-law/ https://kanywst.github.io/hammurabi/laws/brooks-law/ Adding people to a late project tends to make it later, because ramp-up and coordination cost more than they add. https://kanywst.github.io/hammurabi/laws/hyrums-law/ https://kanywst.github.io/hammurabi/laws/hyrums-law/ With enough users, every observable behavior of a system, bugs included, is depended on. https://kanywst.github.io/hammurabi/laws/conways-law/ https://kanywst.github.io/hammurabi/laws/conways-law/ Systems end up shaped like the communication paths of the teams that build them. https://kanywst.github.io/hammurabi/laws/galls-law/ https://kanywst.github.io/hammurabi/laws/galls-law/ Complex systems that work usually grew from simple systems that worked; designed ones rarely do. https://kanywst.github.io/hammurabi/laws/law-of-triviality/ https://kanywst.github.io/hammurabi/laws/law-of-triviality/ Discussion goes to the parts everyone understands, not the parts that matter. https://kanywst.github.io/hammurabi/laws/normalcy-bias/ https://kanywst.github.io/hammurabi/laws/normalcy-bias/ Faced with a real anomaly, people reach for the familiar, harmless explanation. https://kanywst.github.io/hammurabi/laws/chestertons-fence/ https://kanywst.github.io/hammurabi/laws/chestertons-fence/ Code or rules whose origin you don't know look like clutter, which makes them tempting to delete. https://kanywst.github.io/hammurabi/laws/normalization-of-deviance/ https://kanywst.github.io/hammurabi/laws/normalization-of-deviance/ A broken rule that causes no immediate harm quietly becomes the new normal. https://kanywst.github.io/hammurabi/laws/type-1-vs-type-2-decisions/ https://kanywst.github.io/hammurabi/laws/type-1-vs-type-2-decisions/ Teams spend the caution meant for irreversible decisions on ones they could easily undo.