Rules
1,053 rules · page 13 of 22
Set RTO and RPO before failure, not during crisis — define…
Set Recovery Time Objectives (RTO) that define maximum acceptable downtime and Recovery Point Objectives (RPO) that define maximum acceptable data loss before a failure occurs, not during crisis.
Log every mistake for 30 days with date, event…
Maintain an error log for 30 days that records date, what happened, and conditions present for every mistake, without analysis or interpretation, to create raw data for pattern detection.
Automate pattern-based error detection before manual…
Deploy automated grammar checkers, linters, or mechanical validation tools before manual review to catch pattern-based errors, reserving human attention for contextual judgment that tools cannot provide.
Never rely on human vigilance for low-frequency monitoring…
When sustained attention must monitor for low-frequency errors over extended periods (>30 minutes), delegate detection to automated systems rather than relying on human vigilance, because attentional resources degrade predictably regardless of motivation.
Detect errors at the earliest catchable point — correction…
Place error detection checkpoints at the earliest point in a process where the error can first be caught, because correction cost increases exponentially with propagation distance downstream.
Multiply direct correction time by 3x for true cost…
Track the full cost of recurring corrections by multiplying direct time by three to account for context-switching, opportunity cost, and verification overhead, revealing the true resource drain that justifies prevention investment.
When correction exceeds 20% of weekly capacity, shift…
When error correction consumes more than 20% of weekly capacity in a domain, shift resources from faster correction to upstream prevention mechanisms that reduce error generation rate.
Within 24 hours of an error, write one mechanistic…
Within 24 hours of an error, write one mechanistic sentence describing what happened stripped of emotion, then identify the single incorrect assumption the error revealed before the memory reconstructs itself.
Every active goal needs an error budget — define…
For each active goal, define an explicit error budget specifying how many misses, delays, or quality drops per period are acceptable before triggering system review, converting brittle expectations into resilient ones.
Three-tier error budgets
Define error budget thresholds in three tiers—green (within budget, no action), yellow (approaching limits, investigate), red (exceeded, halt and redesign)—with pre-committed responses for each zone.
Decompose error handling into four independent subsystems
Separate error detection, diagnosis, correction, and learning into independent subsystems so each can be improved independently and partial failure doesn't disable the entire error-handling architecture.
After one cycle, review the corrector itself — did…
After deploying a self-correcting mechanism for one cycle period, add a meta-correction review asking whether the correction actually prevented the target error, adjusting the corrector itself if it failed.
Find the leading indicator that appears days before…
For recurring errors, identify the leading indicator that appears days or weeks before full manifestation, not hours, because late signals provide insufficient time for corrective action to prevent the error.
Define non-overlapping agent scopes — scope collisions…
Design cognitive agents with non-overlapping scopes by defining exactly which situations, resources, or decisions each agent claims authority over, treating scope collisions as architecture problems requiring boundary redefinition rather than willpower failures.
Assign exactly one agent as accountable for each decision…
When designing RACI-style accountability for cognitive agents, assign exactly one agent as 'accountable' (final decision authority) for each contested decision or resource, allowing other agents to be consulted or informed but not to hold veto power.
Agent priority orderings must be context-specific — which…
Build priority orderings that are context-specific rather than global, defining which agent takes precedence during specific time blocks, capacity states, or situational contexts rather than attempting universal rankings.
Map agent dependencies and arrange in topological order…
Define cognitive sequences by mapping dependencies between agents (which outputs serve as inputs to which other agents), then arrange agents in topological order so no agent executes before its required inputs are available.
Under stress, follow the written sequence — intuitive…
When cognitive load increases or stress appears, rely on pre-defined explicit sequences rather than intuitive ordering, because implicit sequences degrade under pressure while externalized protocols remain stable.
Specify the information contract at every agent handoff…
At each handoff point between sequential agents, specify the exact information contract (what specific output the next agent needs from the current agent) to make dependencies explicit and auditable.
Parallelize independent agents, serialize only true…
Run independent agents (those with no input dependencies on each other) in parallel to compress total execution time, and serialize only those agents where one genuinely requires the other's output.
The critical path is your minimum duration — no amount…
Identify the critical path (longest chain of dependent tasks) as the minimum project duration, recognizing that no amount of parallelization or additional resources can compress completion time below this constraint.
Map actual information flow to distinguish artificial…
Distinguish artificial serialization (treating independent tasks as dependent) from premature parallelization (launching tasks before their dependencies resolve) by mapping actual information flow rather than assumed ordering.
Pre-define allocation rules for contested time blocks…
Before any contested time block arrives, define the allocation rule (priority ordering, rotation schedule, or time-slice) that resolves contention in advance rather than negotiating access when the block arrives.
Diagnose priority paralysis with Coffman conditions…
Before attempting to resolve paralysis between competing priorities, check whether all four Coffman conditions hold (mutual exclusion, hold-and-wait, no preemption, circular wait)—if so, violate any single condition to make deadlock structurally impossible.
Match allocation mechanism to contention structure…
When multiple goals compete for the same scarce resource, match the allocation mechanism to dependency structure—use priority queue when importance differs, rotation when all are equal, and time-slicing when multiple need access within the same period.
Three-component handoff spec
For each handoff between agents or pipeline stages, specify three components—defined output format, explicit expectations, and return protocol—to prevent ambiguous handoffs from creating bottlenecks.
Never add agents to sequential tasks — only distribute…
Never add agents to sequential reasoning tasks—distribute additional agents only to genuinely parallel workstreams where coordination overhead is measurably less than throughput gain.
Cap coordination at 15-25% of total hours — new…
Set an explicit coordination budget as a percentage of total available hours (15-25% for most knowledge work), and require any new coordination mechanism to fit within that budget or displace an existing one.
Invest in implicit coordination…
Invest in implicit coordination mechanisms—shared mental models, conventions, templates, and routines—over explicit communication channels, because implicit coordination scales without consuming bandwidth as agent count grows.
Protect the conditions that produce beneficial emergence…
For beneficial emergent behaviors, protect the conditions that produced them—keeping agents active, maintaining shared context, and adding lightweight observation—rather than formalizing the pattern into an explicit rule.
Assess agent ecosystem health by checking three pair-level…
When performing ecosystem health assessments, examine agent pairs for three specific failure modes: conflicting outputs, throughput mismatches between producer and consumer, and resource competition for the same limited capacity.
Review new agents 7-14 days after deployment — remove…
Schedule agent addition reviews 7-14 days after deployment to verify whether actual coordination cost matches pre-addition estimates, removing the agent if cost exceeds estimate by more than 50%.
Before retiring an agent, map its three dependency types
Before retiring any agent, map all dependencies by identifying what consumes its output, what constraints it enforces, and what failures it masks—then explicitly reroute, replace, or accept each dependency gap.
Remove agents gradually — reduce frequency before…
When removing an agent, execute graduated shutdown by reducing frequency or scope before full elimination, monitoring for hidden dependencies during the transition period.
Four questions for 30-minute coordination reviews
During 30-minute coordination reviews, answer four diagnostic questions with evidence: which agents produced output, did outputs reach intended consumers, what was the coordination-to-work time ratio, and where did agents actively interfere.
Fix weak coordination by designing explicit handoff…
For agents with weak coordination, design hand-off protocols by specifying what information transfers, in what format, and at what trigger point—then practice the hand-off deliberately in the next three executions.
Classify every task as ONLY ME, COULD DELEGATE, or SHOULD…
Calculate your attention allocation by categorizing each task as ONLY ME (requires unique judgment), COULD DELEGATE (someone/something else can do it at 80%+ quality), or SHOULD NOT EXIST (adds no value), then delegate or eliminate everything outside ONLY ME to reclaim attention for highest-value work.
ONLY ME time below 50% of working hours signals…
When your ONLY ME time falls below 50% of working hours, you have a delegation deficit requiring immediate correction, because spending the majority of your highest-value resource on work that doesn't require it violates the constraint optimization principle.
Distinguish ONLY ME by necessity from ONLY ME by default…
Before delegating a task, verify it is not ONLY ME by default rather than by necessity—if the task requires your unique judgment only because you've never built documentation, systems, or relationships to make it delegable, it's a disguised delegation candidate.
Ask 'can a system handle this?' before 'can a person?'…
Default to the delegation hierarchy sequence: first ask 'can a system handle this?', then 'can a system handle 80% with a person handling exceptions?', and only then 'does this require full human judgment?'—to prevent systematic under-investment in systems.
Before modifying processes, surface their embedded schemas…
When modifying organizational processes, surface embedded schemas first to distinguish processes encoding hard-won lessons (whose removal reintroduces risk) from processes encoding obsolete assumptions (whose removal reduces waste).
When reclaiming a non-delegable decision, retain only…
When reclaiming a delegated decision that scored 2+ on the non-delegable filter, restructure by retaining the non-delegable core (judgment, value trade-off, contextual interpretation) while re-delegating execution (research, analysis, implementation) to preserve leverage without losing identity.
The competent stranger test
Test specification completeness by asking whether a competent stranger with relevant skills but zero context could produce an acceptable result from your specification alone—if not, the missing information must be externalized before delegation.
Three verification layers
Design verification as three independent layers—continuous signals (daily metrics), periodic samples (weekly/monthly spot-checks), and infrequent structural audits (quarterly full reviews)—with each layer optimized for different failure detection at different resource costs.
Transparent verification builds trust, hidden monitoring…
Make verification checkpoints transparent to delegates by communicating what you will check, when you will check it, and what standards apply, because hidden monitoring functions as surveillance while transparent verification functions as professional collaboration.
Cascading verification escalation
When a verification signal degrades, escalate to deeper sampling; when sampling reveals a pattern, trigger a structural audit; when an audit reveals a structural problem, modify the delegation itself—this creates a cascading response protocol where each verification layer can activate the next.
Trust is a dynamic variable — extend verification…
Extend verification intervals when a delegate produces consistent quality outputs over time, and tighten intervals when errors surface, treating trust as a dynamic variable calibrated by accumulated evidence rather than a fixed initial condition.
Scale AI output verification to stakes
For high-stakes AI outputs, adopt a three-tier verification intensity: skim for low-stakes brainstorming, spot-check key claims for medium-stakes communications, and verify every substantive claim for high-stakes published or production content.