The encyclopedia of cognitive moves

Your system breaks because important information lives in one person's head, or is scattered, stale, or lost.

Every part works fine on its own, but meaning, ownership, or quality dies in the gaps between them.

A person, tool, or artifact is carrying work it is badly suited to carry.

Outputs turn into action without any test, limit, or way to catch a bad one before it causes harm.

Nobody knows who may recommend, act, approve, override, or answer for the result.

The arrangement quietly consumes skill, agency, privacy, or resilience even while it works.

One part got faster but the whole got slower once transfer, coordination, and upkeep costs are counted.

Record important information the moment it appears or changes, before it evaporates.

Surface the right information at the exact moment of action, not buried where no one looks.

Keep every copy and every person aligned to one current version of the truth.

Remove obsolete information from active use while keeping what still needs an audit trail.

Split vague work into coherent pieces, each with a clear product and check.

Put dependent steps in order and group similar work to stop constant switching.

Give repeated work a stable template, checklist, or definition of done.

At every transfer, make the state, owner, output, acceptance rules, and exceptions explicit.

Let a tool calculate, sort, reconcile, or compare using explicit inputs and criteria.

Look outside your own memory for information, precedents, or resources that already exist.

Have a tool draft, translate, summarize, or produce variants for a human to review.

Explore scenarios and prototypes before committing, so reality's surprises show up cheaply first.

Let a stable rule run or watch for a condition automatically, always with bounds and an exception path.

Ask a qualified source one scoped question while keeping the decision yourself.

Assign a bounded piece of work with clear authority, acceptance criteria, and accountability.

Work jointly when mutual adaptation and shared context are themselves part of the value.

Get genuinely independent answers before anyone sees anyone else's, then adjudicate.

Send a predefined red flag straight to whoever is actually authorized to handle it.

Place a prompt or object at the exact place and moment the action should happen.

Make the preferred path happen without a repeated choice, while keeping an honest opt-out.

Add a voluntary boundary, delay, or friction before a predictable failure state arrives.

Change layout, proximity, and prepared resources before demanding more willpower.

Give every important piece of information one canonical home with a named owner, and point everything else to it.

At every boundary between sessions, people, or places, record done, next, blocker, and risk in under a minute.

Put one exact prompt at the place and time of the intended action, and delete cues that don't change behavior.

Name and date the current version, then remove old copies so no one can mistake them for the live one.

When a repeated process fails by omission, build the shortest checklist that catches the misses.

State the current state, requested output, owner, deadline, check, and exception path, then ask for confirmation.

Name exactly one person who owns the outcome and give them matching authority and resources.

Map every transfer in a workflow, rank them by delay and error, and remove or redesign the worst one.

Give exact, repetitive, rule-bound work to a tool, but keep interpretation and novel cases with a human.

Run a process manually for 5 to 10 cycles and automate only the part that stays stable.

Define ordinary bounds and route everything outside them to a visible human review queue.

For every dependency that can fail at the moment of need, create the smallest backup path and rehearse it once.

Automate the gathering and formatting, but keep the final decision and its rationale human-owned.

Name the competence your system lacks and ask one scoped question of a qualified source.

Get separate assessments before reviewers see each other's conclusions, with real independence in data or method.

When presence, apology, consent, or care is part of the outcome, the delivery must stay human.

Before trusting a handoff, ask the receiver to explain the result, assumptions, and exceptions in their own words.

Predefine the danger signals, their authorized destination, and the immediate safe action, so the ordinary workflow ends the moment one fires.

Remove one friction from the good path and add one reversible friction to the bad one.

Choose your boundary, trigger, and escape clause before the hot state that will impair your judgment arrives.

Change the layout and availability of things before demanding more motivation from yourself or others.

Share only the information a helper or tool actually needs for the task, and strip the rest.

Move from demonstration to guided work to unaided work, reducing support as real mastery appears.

Before adopting an improvement, list every burden it removes and creates for every actor, now and later.

Before routing any work, define its product, available inputs, operation, keep-safe constraints, edges, and test.

Name the finished thing itself, not the activity that makes it. Describe the artifact or end state precisely enough that someone could hold it up: what form it takes, what it contains, and where it ends up.

Spell out what the worker actually gets: the source data, the files, the logins and permissions, the tools, and any prior work they can build on. Whatever you assume they already have but never hand over becomes the thing that stalls the job.

Name the kind of mental work involved, not the output: acquiring, persisting, representing, generating, computing, judging, coordinating, acting, or learning. Verbs decide the carrier. Anything requiring judgment or coordination cannot be handed to a script, and a task mixing several verbs usually needs splitting.

List the lines the work must not cross: data that stays private, judgments a person must make personally, steps that can never be undone, and skills you still want to build yourself. These are protections, not instructions about what to produce.

Map the connections around the work: what has to arrive before it can start, who receives the output and in what form, what kicks it off, what it depends on, and where the worker sends anything that does not fit the normal path.

Name the check someone could actually run on the finished work to say yes or no. Not a quality feeling, not a deadline: a specific observable condition that settles whether the packet is done, decided before the work starts.