The problem
What the customer needs
- A clear answer, before work starts, on what client data is safe to put into Claude.
- Confidence about when AI involvement needs to be disclosed to the client, and when it doesn't.
- A human checkpoint placed where the actual risk is, not a vague sense that "someone should probably look at this."
Why naive approaches fail
- Assuming all client data is fine to use because "it's just for drafting, not the final version", sensitive data doesn't become safe because the use felt casual.
- Never mentioning AI involvement to the client, not because it was deliberately weighed and decided against, but because it never came up.
- Treating "a human looked at it eventually" as equivalent to a real human-in-the-loop checkpoint placed before the risky step.
- Data sensitivity is checked against organizational policy before any client data enters Claude
- A deliberate decision, not silence, has been made about whether this engagement requires AI-use disclosure to the client
- Human-in-the-loop checkpoints are placed before the highest-risk step, not after the fact
- The reasoning behind each of these calls is written down, not just remembered
The system
What each part does
5 components, each owns a concept. Click any card to drill into the underlying primitive.
Data Sensitivity Check
before, not after, data enters Claude
A short, explicit check of what kind of client data the task involves, against your organization's actual policy, before any of it gets uploaded or pasted in. This is the single highest-leverage moment in the whole scenario: everything downstream depends on this being right.
Configuration
Ask: does our policy classify this data as restricted (PII, confidential financials, regulated data) or general working material? If restricted, does the approved Claude product tier and workspace configuration meet that bar? If either answer is unclear, the data waits.
Disclosure Decision
a deliberate call, not a default of silence
Whether the client needs to know AI was used in producing a deliverable is a decision that should be made on purpose, weighing the client relationship, the nature of the deliverable, and any contractual or regulatory expectation, not left to whatever happens by default.
Configuration
Default assumption: if AI materially shaped a client-facing deliverable's content (not just formatting), lean toward disclosure unless there's a clear, documented reason not to. Silence should never be the unexamined default.
Human-in-the-Loop Checkpoint
placed before the risky step, not after
A specific point in the workflow where a human must review and approve before the work proceeds, positioned at the step where an error would actually cause harm, not wherever felt convenient to insert a review step.
Configuration
Identify the single highest-risk step in the workflow, sending to the client, acting on a recommendation, making a financial decision, and place the mandatory human checkpoint there, even if lighter checks exist elsewhere.
Appropriateness Filter
should this task use Claude at all
Before any of the above, a quick check on whether this task is an appropriate use of AI in the first place, some decisions (legal judgment calls, decisions requiring accountability that can't be delegated, certain regulated determinations) shouldn't be handed to Claude regardless of how well it could draft an answer.
Configuration
Ask: is this a task where the output is a draft a human will judge, or a decision Claude's output would effectively make? The former is generally appropriate; the latter needs a human decision-maker, with Claude at most informing that decision.
Written Rationale
so the call is defensible later
A short written note capturing why each of these calls was made the way it was, kept with the engagement record. This is what lets the team (or the client, or a regulator) understand the reasoning months later, instead of relying on someone's memory of a judgment call.
Configuration
One paragraph per engagement: data sensitivity determination, disclosure decision and why, where the human checkpoint sits and why there.
Data flow
6 steps to production
Run the appropriateness filter before anything else
Before deciding how to use Claude on a task, decide whether the task is an appropriate use of AI in the first place. Decisions that require human accountability that can't be delegated should keep Claude in an informing role, not a deciding one.
↪ Concept: appropriate-ai-use-casesCheck data sensitivity against policy before any data enters Claude
Classify the client data the task involves against your organization's actual data-handling policy. If the data is restricted and the approved product tier or workspace doesn't clearly meet that bar, the data waits until it does, no exceptions for "it's just a draft."
↪ Concept: organizational-ai-governance-policyMake a deliberate disclosure decision
Explicitly decide, and document, whether this deliverable requires telling the client AI was involved. Default toward disclosure when AI materially shaped the content of a client-facing deliverable, unless there's a clear, documented reason not to.
↪ Concept: ethical-ai-considerationsPlace the human checkpoint at the highest-risk step
Identify the single point in the workflow where an error would cause the most harm, sending to the client, acting on a recommendation, a financial or legal decision, and require human sign-off specifically there, not spread thin across every minor step.
Write the rationale down
Record, in a short note kept with the engagement, why each call was made this way. This is what turns a one-time judgment call into something the team, the client, or a reviewer can understand and trust later.
Revisit if the engagement's data or stakes change
A data-sensitivity or disclosure decision made at kickoff may not hold if the engagement later touches more sensitive data or a higher-stakes deliverable. Treat these as living decisions tied to the actual work, not a one-time form filled out and forgotten.
The four decisions
| Decision | Right answer | Wrong answer | Why |
|---|---|---|---|
| Client data with PII or regulated content | Check against organizational policy before it enters Claude | Use it because it's "just for an internal draft" | Sensitive data doesn't become safe because the use felt casual or temporary. The policy check happens before the data moves, not after. |
| Whether to tell the client AI was used | A deliberate, documented decision, weighing the relationship and the deliverable | Silence by default, because it never came up | Undisclosed AI involvement, discovered later, damages trust far more than a proactive, well-reasoned disclosure would have. |
| Where the human-in-the-loop checkpoint sits | Before the highest-risk step in the workflow | Wherever a review step happened to be inserted | A checkpoint after the risky step has already happened doesn't prevent the harm, it only documents it after the fact. |
| A task involving a decision requiring human accountability | Claude informs the decision; a human makes it | Claude's output is treated as the decision itself | Some decisions carry accountability that can't be delegated to a tool, regardless of how well-reasoned the output reads. |
Where it breaks
4 failure pairs. Each maps to an exam-style question - the naive move on the left, the disciplined fix on the right.
Sensitive client financial data gets pasted into Claude because the output is "only for an internal working draft."
AP-CCAOF-D6-01Apply the same data-sensitivity policy check regardless of whether the output is a draft or final, the data's sensitivity doesn't change based on downstream use.
AI materially shaped a client deliverable's content, and disclosure was never discussed, it just didn't come up.
AP-CCAOF-D6-02Make disclosure a deliberate, documented decision every time, not a default that only happens if someone happens to raise it.
A human "reviews" a client email only after it's already been sent, treating that as the human-in-the-loop step.
AP-CCAOF-D6-03Place the mandatory human checkpoint before the risky action, sending, acting, deciding, not as a retrospective look-back.
A judgment call requiring personal professional accountability gets treated as settled once Claude produces a well-reasoned answer.
AP-CCAOF-D6-04Use Claude's output to inform the decision. The accountable human still has to make the call, not rubber-stamp Claude's.
Cost & latency
The appropriateness filter, data check, and disclosure decision together are a short, deliberate exercise done once at the start of an engagement's Claude use.
Undisclosed AI use or a mishandled sensitive-data decision damages client trust in a way that's disproportionate to the small amount of time the check would have taken.
Deciding data sensitivity, disclosure, and checkpoint placement upfront avoids the much larger cost of resolving these questions reactively after a client raises them.
A paragraph-length record is a small ongoing cost that pays for itself the first time a governance decision needs to be explained later.
Ship checklist
Two passes. Build-time gates verify the code; run-time gates verify the system in production.
Build-time
- Appropriateness filter run before deciding how to use Claude on a task↗ appropriate-ai-use-cases
- Data-sensitivity check against organizational policy happens before any data enters Claude↗ organizational-ai-governance-policy
- Disclosure decision made deliberately and documented, not left to default silence↗ ethical-ai-considerations
- Human-in-the-loop checkpoint identified and placed before the highest-risk step
- Written rationale for each call kept with the engagement record
- Data-sensitivity and disclosure decisions revisited if the engagement's scope or stakes change
Run-time
- Organization's data-handling policy is known and accessible to the delivery team, or its absence is flagged
- Disclosure decisions are made deliberately at engagement kickoff, not left implicit
- Human-in-the-loop checkpoints are mapped to the workflow's actual highest-risk steps
- Written rationale exists for engagements involving sensitive data or high-stakes deliverables
- Team knows which decisions can't be delegated to Claude regardless of output quality