ChatGPT Work tutorial for reviewable knowledge workflows

Act as a work-surface selector. Do not take action.

Task: [one real task]
Source of truth: [files / connected sources / repository / web]
Finished artifact: [memo / sheet / deck / report / diff]
Action boundary: [read-only / draft only / approved write]

Return exactly:
1. Recommended surface: Chat, Work or Codex
2. Why the source and artifact require it
3. First safe action
4. Sources, files or tools to inspect
5. Proof a reviewer needs
6. One assumption that could change the recommendation

Turn this messy request into a one-screen deliverable contract. Do not research or draft yet.

Raw request: [notes, voice transcript or bullets]

Return exactly:
- outcome and decision it supports
- reader and deadline
- approved sources and excluded sources
- non-goals and constraints
- output format and required sections
- evidence and citation standard
- reviewer and approval point
- stop condition
- only the questions that would materially change this contract

Produce a reviewed first version, not a generic answer.

Outcome: Create [artifact] for [reader] so they can [decision/action].
Approved context: [Project instructions, files, apps, approved websites].
Exclusions: [sources, actions or claims not allowed].
Evidence standard: [citations, calculations, source dates].
Review owner: [person].

First return: scope, assumptions, source plan and stop condition.
Then return: a structured draft with cited facts, labeled inferences, open questions and a reviewer checklist.
Pause before external actions, final sharing or any use outside the approved context.

Create a Project context card for one ongoing workflow. Do not treat the Project as enforcement.

Purpose: [purpose]
Audience: [audience]
Sources: [files, instructions, apps]

Return a table with: source; authority (system of record / derived / reference / archive); owner; freshness or review trigger; allowed use/audience; conflict route.
Then add: required definitions, facts that need citations, approved output style, actions requiring approval and the rule for uncertainty. Show conflicts and stale sources instead of silently choosing a winner.

Build an evidence receipt before synthesis. For each claim or question, return: source locator and version/date; authority; stated fact or inference; access/audience boundary; freshness/confidence; reviewer; and conflict or missing-evidence route. A summary does not extend source permission or turn an inference into a fact. Do not use a source until its allowed use is stated.

Create a reviewable [document / spreadsheet / presentation].

Decision: [decision]
Reader: [reader]
Required sections: [sections]
Approved sources: [sources]
Non-negotiables: [formulas, layout, facts, tone]

Return an outline and source map first. Then create a structured draft that flags missing or inconsistent data, labels assumptions and provides a final reviewer checklist. Do not fill gaps silently or share externally without approval.

Create an action authority matrix for this workflow.

Sources and apps: [list]
Potential actions: [list]

For read, draft, propose and execute, state: exact allowed action; named human approver; evidence required; fallback when access is missing; and must-never action. Do not log in to new services, send messages, publish content, edit shared files or submit forms without exact approval. Do not bypass a missing permission or connector restriction through another surface.

Run this as a bounded operating loop.

Trigger/cadence: [trigger]
Approved context: [sources and exclusions]
Output: [artifact]
Verifier: [person and acceptance check]

Return checkpoints for plan, source receipt, first findings, draft, review pause, revision and handoff. At each checkpoint state completed work, changed evidence, decisions needed, risks, next trigger and stop condition. If a source or permission is missing, report the blocker and correction route instead of improvising.

Design one reusable workflow template only after a manual run was accepted.

Manual proof: [what worked and who accepted it]
Trigger: [event or cadence]
Inputs: [approved sources]
Output: [artifact]

Return: trigger phrases; required inputs; output format; authority boundary; validation checks; named owner; review cadence; retirement condition; a material-change rule; and a safe dry run. Report only material changes. Do not schedule, send, publish or create external actions. If the manual proof is missing, return the smallest manual test instead.

Draft a governed pilot worksheet, not an enterprise assurance claim.

Workflow owner: [owner]
Data steward: [owner]
Policy/risk owner: [owner]
Verifier: [owner]
Action authority: [owner]
Incident/stop owner: [owner]
Users and workspace: [users/workspace]

Return approved apps and source boundaries; action authority matrix; sensitive-data rules; source/citation standard; acceptance evidence; training; review cadence; exception and stop route; and rollback or retirement plan. Link feature/permission assumptions to current OpenAI documentation.

Diagnose this failed workflow. Separate outcome ambiguity, source quality, permission limits, platform availability and task scope. Propose the smallest test that distinguishes the likely causes. Do not claim a product limitation without evidence.

Prepare a durable state record for a teammate who did not see this conversation.

Artifact and version: [link/version]
Purpose and decision: [purpose]

Return exactly:
1. Source receipts and as-of dates
2. Stated facts versus inferences
3. Accepted and rejected decisions
4. Assumptions and unresolved questions
5. What changed or was confirmed
6. Verifier and acceptance evidence
7. Next owner, trigger and review date
8. Project instructions or templates to update
9. Whether the next step stays in Work or moves to Codex, and why