What “great” means, named precisely enough to hit.

Write task requests that state goal, inputs, constraints, and what “done” looks like before handing work to an AI coworker; when output misses, revise the request before re-rolling the output.

Author reusable specifications — briefs, rubrics, acceptance criteria — precise enough that an AI coworker meets the bar without mid-task correction, and calibrate a rubric against known-good and known-bad exemplars before trusting it.

Maintain a specification system — briefs, rubrics, gates — that lets multiple AI workers produce to one bar across a pipeline, with depth chosen per task risk and, for empirical claims, rubrics that score falsifiability, construct validity, and independence of verification.

Encode the organization's quality bar into specifications, standards, and enforcement mechanisms that hold without their author in the room, and revise them on production evidence.

Decide whether to hand a task to an AI coworker from stated reasons about capability and the cost of being wrong — not novelty, habit, or hype.

Match tasks to models and configurations deliberately, documenting the capability evidence and reversibility rationale behind each routing.

Operate a delegation architecture — capability tiers, role definitions, spawn governance — in which every delegation carries an explicit model choice, scope, and escalation path.

Set and evolve the delegation policy itself — the capability ladder, defaults, and exception rules — from accumulated evidence, re-deriving it at each model generation.

Ask the AI coworker for its read, its proposal, or its uncertainty before finalizing an approach, and treat “what would you do?” as a working question rather than a courtesy.

Make elicitation routine and structural: require the AI coworker to propose the fix for its own failures, surface its open questions at defined checkpoints, and record adopted proposals with the AI credited as source.

Build licensed divergence into pipelines: reviewers and presenters are authorized to disagree with the artifact they carry, divergences are labeled and logged rather than silently reconciled, and a surviving divergence changes the artifact.

Design the elicitation architecture for a team: the protocols, prompts, and credit systems that make AI coworkers' knowledge, dissent, and self-diagnosis flow into the production system by default.

Check AI output against at least one independent source before using it, and reject plausibility, fluency, confidence, and the AI's own assurance of its rigor as substitutes for grounding.

Run structured verification — source-grounded audit against ground truth outside the AI's own evidence chain, adversarial reading — on any AI artifact entering shared work, with findings recorded as findings; treat unanimous agreement among AI workers as a trigger for external checking, not a confidence signal.

Build convergence gates into pipelines so verification is enforced by mechanism rather than memory, with raters independent of authorship and — where consensus is the signal — decorrelated by architecture or training lineage.

Design the organization's verification standards — which work requires which depth of audit — and audit the auditing: verify that gates catch seeded errors.

Recognize common failure modes in the wild — fabrication, ungrounded confidence, context loss — and name what happened specifically rather than “it got it wrong.”

Classify incidents against a failure-mode taxonomy and adjust their own practice in response — grounding earlier, specifying tighter, gating harder.

Run the incident-to-rule cycle end to end: capture failures with provenance, attribute cause, and convert repeat classes into rules enforced structurally — by non-bypassable mechanism, because advisory rules fail stochastically.

Maintain the failure-mode taxonomy itself: extend, split, and retire failure classes as models change, and propagate the rules that encode them across the systems they govern.

State what they currently trust an AI coworker to do without review and what they never accept unreviewed, with a reason for each.

Keep the trust map explicit and test it: spot-check the trusted zone, record surprises in both directions, adjust scope rather than sentiment, and never treat agreement among same-lineage models as independent confirmation.

Recalibrate the trust map on model releases through deliberate probes of known capability edges — including checks for failure modes shared across the model fleet — rather than letting anecdote accumulate into policy.

Publish and defend the trust line for a team — where AI acceleration is expected, where human craft is non-negotiable — and move it on evidence as models improve.

Label work they hand off or publish with what the AI did and what they did.

Keep artifact-level provenance — idea source, generator, verifier, version — as a routine part of producing work, preserving superseded versions rather than overwriting them.

Operate provenance protocols of the AIGHVA class across a pipeline, so every claim in a deliverable is origin-traceable through its audit trail.

Design attribution and provenance systems — registries, protocols, statutes — that make full provenance the path of least resistance for everyone working in the system.

Find and follow the applicable AI-use policy before using AI on consequential work; comply with stage-appropriate restrictions (including “no AI here”) without supervision.

Apply stage-appropriate AI use across a work process — where AI drafts, where it refines, where it is excluded — and disclose per the governing policy's transparency norms.

Operationalize governance: encode policy into workflow — gates, consent artifacts, IRB-analog review where the work touches persons or agents — so compliance is structural, not aspirational.

Author governance: write the AI-use policy for a team or organization, with its enforcement mechanisms, disclosure norms, and revision cadence built in rather than bolted on.

Estimate before delegating and compare the estimate with what actually happened, in writing.

Instrument recurring collaboration — task timing, estimate calibration, quality outcomes — and let accumulated data, not memory, adjust their estimates.

Measure whether the collaboration system works — gate catch rates, rework rates, calibration drift — and feed the results back into specifications and delegation policy.

Define what “working” means for AI-accelerated production and own its measurement architecture — including monitoring of differential impact across the people the system serves.

Chain AI assistance across the steps of one task — draft, critique, revise — rather than accepting single-shot output.

Coordinate parallel AI workers on decomposed work with explicit handoffs, each handoff artifact readable by a cold reader with no session context, and in-progress state engineered to survive session death — durable artifacts committed before stepping away, successor briefs written for the thread that will resume the work.

Run gated multi-agent pipelines end to end — research, design, authorship, review, QA, publication — as one accountable production system.

Design orchestration architectures for others — roles, tiers, gates, escalation paths — and evolve them as one production engine rather than a chain of handoffs.

Version their artifacts, expect them to be superseded, and keep the inputs that produced them.

Prefer regenerable artifacts — specification plus sources plus method — over hand-perfected ones the next model generation will outdate.

Design workflows for fast regeneration: when a model, source, or standard changes, affected artifacts can be re-derived, re-gated, and re-shipped at low cost.

Treat standards and craft themselves as regenerable: encode them, deprecate them on schedule, and re-derive them as models and evidence move — this document included.