What this system is, and its 5 parts
At some point in almost every client engagement, someone has to make a call that isn't about whether Claude can do a task, it's about whether it should, and how. Can this client's contract data go into Claude at all. Does the client need to know AI was used in this deliverable. Does a human need to sign off before this goes out, or is a spot-check enough. These are judgment calls, not technical questions, and getting them wrong damages trust in a way a wrong number never does. This scenario walks through how to make that call well, every time, not just when it happens to occur to you.
Data Sensitivity Check
before, not after, data enters ClaudeA 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.
ConfigurationAsk: 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.Concept: organizational-ai-governance-policy →
Disclosure Decision
a deliberate call, not a default of silenceWhether 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.
ConfigurationDefault 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.Concept: ethical-ai-considerations →
Human-in-the-Loop Checkpoint
placed before the risky step, not afterA 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.
ConfigurationIdentify 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.Concept: organizational-ai-governance-policy →
Appropriateness Filter
should this task use Claude at allBefore 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.
ConfigurationAsk: 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.Concept: appropriate-ai-use-cases →
Written Rationale
so the call is defensible laterA 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.
ConfigurationOne paragraph per engagement: data sensitivity determination, disclosure decision and why, where the human checkpoint sits and why there.Concept: ethical-ai-considerations →
The problem
- 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."
- 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
One run, traced end to end
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-cases →Check 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-policy →Make 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-considerations →Place 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.
8 decisions the exam turns into distractors
Use it because it's "just for an internal draft"
Check against organizational policy before it enters Claude
Silence by default, because it never came up
A deliberate, documented decision, weighing the relationship and the deliverable
Wherever a review step happened to be inserted
Before the highest-risk step in the workflow
Claude's output is treated as the decision itself
Claude informs the decision; a human makes it
Sensitive client financial data gets pasted into Claude because the output is "only for an internal working draft."
Apply 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.
Make 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.
Place 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.
Use 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.
Check every gate before release
4 exam-pattern questions
Work through one question at a time, check the architecture, then move through the set.
A team member wants to paste a client's confidential financial data into Claude, reasoning that it's "just for an internal draft, not the final deliverable." Is this reasoning sound?
Frequently asked
How do I know what counts as "restricted" client data if my organization doesn't have a written policy yet?
In the absence of a written policy, treat anything personally identifiable, financially sensitive, or contractually confidential as restricted by default, and check with a manager or legal contact before proceeding. Absence of a policy is not permission, it's a reason to be more conservative, not less.
Do I need to disclose AI use for every single client interaction?
No. The judgment call is about material shaping of content in a client-facing deliverable, not incidental use like formatting help or a personal note-taking aid. The point is a deliberate decision, not blanket disclosure or blanket silence.
What if the client would clearly be uncomfortable with AI involvement if asked?
That discomfort is itself important information for the disclosure decision, and often a strong signal toward proactive, careful disclosure and a conversation about how AI is being used, rather than avoiding the topic.
Isn't a single human checkpoint enough, regardless of where it sits?
No, placement matters as much as existence. A checkpoint after the risky step has occurred, sent, acted, decided, doesn't prevent the harm. The checkpoint needs to sit before that step, or it isn't functioning as a control.
What kinds of tasks should never be fully delegated to Claude, even as a draft?
Tasks where the decision itself carries personal or professional accountability that can't be transferred, certain legal judgment calls, decisions with regulatory sign-off requirements, or anything where "an AI decided this" wouldn't be an acceptable answer to a client or regulator.
Does this whole process need to happen for every small task, or just bigger engagements?
The appropriateness filter and data check are worth a quick mental pass on every task. The fuller written rationale is proportional to stakes, a quick internal task doesn't need the same documentation as a high-stakes, sensitive client engagement.