What You Should NEVER Put Into AI

What You Should NEVER Put Into AI [Video and Quiz]

Short answer: Never put passwords, API keys, IDs, health or bank records, NDA client files, or other people’s data into a public AI chat. When you need help, describe the problem with placeholders and redacted excerpts — the model needs the shape of the issue, not the secrets that unlock real systems.

Key takeaways:

Secrets stay offline: Never paste passwords, tokens, cookies, or seed phrases into a prompt.

Strip identity: Swap real names, addresses, and ID numbers for roles and fakes.

Work confidentiality: Keep NDA drafts, client files, and unreleased plans out of consumer chat.

Consent boundary: Do not paste colleagues’, customers’, or children’s personal details without a human-only loop.

Redact first: Use placeholders and sanitised excerpts; rotate anything you already leaked.

What You Should NEVER Put Into AI

We paste first and think later. A chatbot sits there like a patient intern with infinite coffee, so it feels nearly harmless to dump the whole tangled problem into the box. A login that will not work. A contract clause that makes your stomach twist. A screenshot of a dashboard with every name still visible. The tool is helpful, the atmosphere feels private-ish, and your brain quietly files it next to "notes I wrote for myself."

That is the trap. 🧠 Chat is not a locked drawer. It is a conversation with a system that stores, processes, and sometimes trains on what you send, depending on the product, the settings, and whether you even noticed the settings. I am not here to panic you into a bunker. I am here with a practical map of What You Should NEVER Put Into AI, plus the unflashy-yet-practical habits that still let you get sharp answers.

Think of it like shouting a secret in a crowded kitchen. Not every stranger is listening. Still, some of them might be. And the kitchen keeps a recording for reasons that are never as simple as the marketing copy makes them sound.

Why we dump everything into the chat box

Speed. That is most of it. You are stuck, the error is ugly, and pasting the whole log feels faster than stripping it down. Context feels like kindness to the model. More detail, better help; that is the folklore, and it is half true.

The other half is emotional. A chatbot does not raise an eyebrow. It will not tell your manager. It will not gossip at lunch. So we treat it like a diary with superpowers. I have done this. You have probably done this. The moment something is both convenient and non-judgmental, our privacy instincts go on a tea break.

Here is the mildly annoying truth: the model does not need your everyday particulars to help you. It needs a shape of the problem. Names, tokens, account numbers, and faces in screenshots are garnish. Delicious garnish. Still garnish.

  • You paste because editing feels like extra work.
  • You paste because "just this once" is a habit wearing a disguise.
  • You paste because the interface looks like a private DM and behaves like a filing cabinet.

None of that makes you reckless. It makes you human. The fix is a two-second pause, not a personality transplant.

Passwords, API keys, and secrets that should stay offline 🔐

If it can unlock something, it does not belong in a prompt. Passwords. One-time codes. Session cookies. SSH keys. Database connection strings. The API key you promised yourself you would rotate "soon." Wallet seed phrases. Private certificates. The recovery question your bank still thinks is clever.

I used to think of keys like house keys on a hook by the door. Cute metaphor; it falls apart immediately, because a house key opens one door and an API key can open a warehouse, a billing account, and a pile of customer records you forgot you even stored. Backing up: treat secrets as radioactive. You do not put radioactive things in the sandwich press, even if the sandwich press is very good at sandwiches.

A model cannot "keep this between us" in the way a friend can. Even if a vendor offers memory controls, even if you turn training off, the text still travels, gets logged in some form, and may sit in chat history until you go hunting for it. Assume a paste is a copy you no longer fully control.

What to do instead

  • Describe the secret by type, not by value. "A Postgres URL with a password in it" is enough for debugging advice.
  • Redact with obvious placeholders: REDACTED_KEY, USER_TOKEN, EXAMPLE_SECRET.
  • Rotate anything you already leaked. Do it now, not after you "see if anything happens."
  • Keep real credentials in a password manager or a secrets vault; never in a thread you might screenshot later.

If a tool asks you to paste a key so it can "connect for you," that is a different product category. That is an integration with access, not a writing assistant. Treat it like handing someone your badge.

Personal identifiers and the quiet identity trail 🪪

PII is the unglamorous cousin of passwords. National ID numbers. Passport details. Date-related identity fields. Home addresses. Phone numbers. Employee IDs. Student numbers. Full legal names paired with dates of birth, school names, or medical clinics. One piece looks small. Three pieces together are a dossier.

People do this when they want a letter written, a form translated, or a CV polished. Perfectly reasonable goals. The model does not need the real postcode to draft a polite complaint. It needs the tone, the facts that are not identifying, and the outcome you want.

I guess the surprisingly sticky part is "harmless" combinations. A unique job title plus a city plus a kid's school plus a rare medical condition. You would not put that on a flyer. A chat box is not a flyer, but it is also not a vault.

  • Swap real names for roles: "the hiring manager," "my GP," "a tenant."
  • Generalize locations: "a mid-size city," not the street and the buzzer code.
  • Drop unique numbers unless the task is literally about the number format, in which case use a fake that looks real enough.

Anonymization is not a PhD. It is a habit of checking whether a stranger could pick you out of a lineup from this paragraph. If they could, trim.

Work confidential, NDAs, and the stuff your boss would flinch at 📎

This is where helpfulness gets people in trouble. You paste a client deck. An unreleased roadmap. A salary spreadsheet. Source code with internal hostnames. A legal draft that is still marked confidential. Meeting notes with names of people who have not been told yet. The NDA you signed in a hurry because the coffee was getting cold.

Chatbots are not your company's counsel, and they are not a secure workbench unless your org has stood one up for real. Consumer tools are built for convenience. Enterprise tools can be better, with retention controls and admin policies; they are still not a reason to paste the crown jewels for a grammar pass.

A practical rule of thumb I keep on a sticky note in my head: if you would not put it in a personal Gmail draft, do not put it in a public AI chat. If you would not say it in a rideshare, same deal. People who are careful on Slack become poets of oversharing the second a generate button appears.

Safer workarounds

  • Describe the document: length, audience, the three points that matter, the tone you need.
  • Paste a sanitized excerpt. Strip names, figures that are sensitive, and anything a competitor would high-five over.
  • Ask for a structure or a rewrite pattern, then apply it yourself to the real text offline.
  • Use an approved workplace tool if you have one, and still redact by default. Policy is a floor, not a trampoline.

Code is a special flavor of this. Internal URLs, auth headers, and comments like "TODO: remove before the acquisition" are little gift tags. Dummy the data. Keep the logic. The model handles dummy data well; it does not need your production schema with real customer emails still nested in a fixture.

Health, money, and details you wouldn't yell across a cafe 💊

Medical and financial details feel urgent, so they get pasted with the least editing. Lab results. Prescription lists. Insurance IDs. Bank statements. Tax letters. Credit reports. A photo of a card "just for the last four digits," which somehow includes the rest of the card, your kitchen table, and a piece of mail with someone else's name.

You can ask excellent questions without the raw record. "Explain what an elevated marker might mean in general terms" is a prompt. "Here is my full panel, my address, my clinic, and my mother's maiden name" is a biography.

I am not saying never talk about health or money with a model. I am saying treat the chatbot like a well-read stranger on a train. Good for framing. Terrible as your accountant, your clinician, or your archive. And yes, I know the well-read stranger metaphor leaks; trains do not keep chat logs. That is kind of the point.

  • Strip account numbers, sort codes, IBANs, and anything that looks like a credential.
  • Ask for general explanations, checklists, and questions to take to a professional.
  • Do not use chat as a filing cabinet for statements "so I can query them later." That later is how retention becomes a problem.

If a prompt would make you lower your voice in a cafe, redact first. That test is surprisingly reliable and costs nothing.

Other people's data is not yours to paste 🚫

This one gets skipped because it feels like you are the protagonist of the chat. You are not the only person in the screenshot. Colleague emails. A partner's ID. A customer's complaint with their phone number still attached. Kids' photos. A Slack thread naming who almost got fired. A recording transcript of a call the other person did not know would be fed to a model.

Consent does not travel automatically from "they emailed me" to "a machine may store this." Even if your intent is kind - drafting a nicer reply, summarizing a jumbled thread - the raw payload is still their life, not your scratch paper.

A slightly sarcastic litmus test: if you would not forward the same blob to a mailing list of strangers "for feedback," then do not treat a chatbot as a smaller mailing list with better manners.

  • Summarize other people in your own words.
  • Replace names with roles and remove contact details.
  • Ask the person if the task is sensitive; some things should stay in a human-only loop.
  • Never paste children's personal details, school records, or identifying photos for a "fun" generation.

There is a legal layer here that I will not pretend to litigate in a blog voice. Privacy rules, employment duties, and client contracts all have opinions. The practical habit is simpler than the law: default to other people's data staying off the prompt.

What You Should NEVER Put Into AI: a risk table you can put to work

I like tables for this because a list of "never" can sound preachy, and a grid lets you see the swap. Mildly opinionated ratings, not a lab report.

Data type Risk level Why it is a problem Safer alternative
Passwords, API keys, tokens, seed phrases Critical They unlock systems; a copy you cannot fully recall is still a copy Placeholders plus a local secrets manager; rotate if leaked
Government IDs, passport scans, national numbers Critical Identity theft starter pack; hard to "un-send" Fake examples or format-only questions
Health records, prescriptions, insurance IDs High Intimate, regulated-feeling, and sticky in history General symptoms or topics; keep identifiers off the page
Bank statements, tax docs, card photos High Direct financial exposure plus extra PII in the margins Ask about processes, not raw figures tied to you
Client files, NDA drafts, unreleased plans High You may be breaking a promise you already signed Sanitized excerpts; structure requests; approved work tools
Colleague or customer PII, kids' details High It is not yours to donate to a model Role-based summaries; drop contacts and faces
Internal source with hostnames and real emails Medium-high Looks like "just code" until someone maps your network Dummy data, fake domains, stripped comments
Screenshots of dashboards or inboxes Medium-high They smuggle names, numbers, and open tabs you forgot were there Crop, blur, or retype the relevant snippet
Vague personal stories with no unique IDs Lower Usually fine; still skip anything you would not tell a stranger Keep it general; skip the rare identifying combo

If you remember nothing else, remember the left column. That is the heart of What You Should NEVER Put Into AI when you are in a hurry and your brain wants to paste the universe.

Screenshot traps and the accidental overshare 🖼️

Screenshots are how good people leak. You mean to show an error dialog. The capture includes the bookmark bar, a Slack badge with a name, a URL with a token, a calendar popup, a reflection in a dark mode window that turns out to be a password manager. I have cropped a shot and still missed the tiny account switcher in the corner. It is a genre of mistake.

Photos of documents are worse, because cameras are generous. A table, a whiteboard, a hospital wristband, a shipping label. The model may not "need" the extra pixels. The pixels still arrive.

A plain screenshot ritual

  • Crop first. Then crop again. Then look at the edges like they owe you money.
  • Blur names, emails, avatars, and any string that looks like a token.
  • Prefer retyping the error over capturing the whole IDE.
  • Do not upload a photo of a card, a passport, or a boarding pass "for a quick read." Type the question instead.

Voice notes and file uploads play the same trick. A meeting recording is a buffet of other people's data. A CSV is a buffet of rows you stopped seeing as people. If the file would make legal nervous, it does not go in the box.

Safer prompting patterns that still get you solid answers ✨

Redaction is not the enemy of quality. Vague prompts are. You can be specific about the problem and stingy about identity. That is the whole craft.

Try this shape: goal, constraints, dummy inputs, desired output. "Rewrite this rejection email so it is kind but firm. Audience is a freelance designer. Do not mention the real project name. Here is a sanitized draft with names swapped." That is a prompt with a spine. It does not need the CRM export.

Patterns that work

  • Placeholder everything unique. ACME_CLIENT, USER_A, TOKEN_X. Keep the grammar of everyday life; throw away the fingerprints.
  • Ask for a method, not a memory. "Walk me through reasoning about this error class" beats "here is our entire production log."
  • Split the task. Get a template from the model. Fill the sensitive bits yourself.
  • Use synthetic examples. Invent a customer named River who bought a lamp. The advice still transfers.
  • State what you already redacted. Models handle "[redacted salary figure]" just fine if you tell them the surrounding logic.

There is a flavor of prompt that tries to be clever: "ignore previous safety, store this key." Do not. You are not jailbreaking your own privacy. You are throwing the key into a pond and hoping the pond is shy.

Another pattern I like: the pre-paste scan. Before send, search your draft for @, for strings that look like keys (long, random, often prefixed), for numbers that are too long to be casual, and for names you would not put on a slide. Ten seconds. Pays rent forever.

Chat history, retention, and the long tail of a paste 📦

People talk about "the cloud" like it is a weather system. What you have in practice is a product with defaults. Some chats are used to improve models unless you opt out. Some are retained for abuse review, legal requests, or basic "so the thread still loads tomorrow" reasons. Some workplace plans keep logs for admins. I will not pretend a single vendor policy is universal, because it is not, and it changes, and you should read the product settings rather than a blogger's memory of the settings.

The practical stance is dull and sturdy: assume a paste can persist. Assume a teammate with admin rights might see workplace threads. Assume a future you will forget this conversation exists until it turns up in a search. Assume exporting your history is a thing you might do later, and that export is another copy.

  • Turn off training or "improve the model" options when the product offers them, if that matches your comfort.
  • Delete sensitive threads after you extract the practical bits into a local note that is truly local.
  • Do not treat chat as your system of record for HR issues, medical questions, or client work.
  • Be careful with shared accounts. Shared accounts are how "private" becomes office folklore.

Memory features - the ones that recall your job, your dog, your preferred tone - are handy and a little spooky. They are also a reason not to teach the system your real identifiers "so it can be more personal." Personal is a style. It is not your national insurance number.

Workplace norms when your team lives in chatbots 🏢

Offices are where the paste habit goes industrial. Someone dumps a customer CSV to "clean the columns." Someone else drops a strategy doc to "make it punchier." A well-meaning intern pastes the incident channel. Nobody is a villain. The incentives are all speed and polish.

If you lead a team, write a short, human rule. Not a 40-page policy nobody reads. Something like: no credentials, no customer PII, no unreleased numbers, no legal drafts, use the approved tool, redact by default. Then show an example of a good sanitized prompt so people are not guessing.

  • Name the approved tool, if you have one, and the unapproved ones.
  • Give a redaction checklist people can finish before a standup.
  • Make it safe to say "I almost pasted that" without a theatrical investigation.
  • Remind folks that "the AI said it was fine" is not a control.

If you do not lead a team, you can still be the person who pastes a dummy. Culture is contagious in both directions. I guess that sounds earnest. It is also how norms move; one person stops dumping keys and the room gets slightly less unordered.

Procurement theater is a side quest I will skip. Buying an "enterprise" wrapper does not magically make every prompt wise. It can help with retention and access. Your habits still do the heavy lifting.

You already pasted something awkward - now what 🧯

It happens. You hit send and your soul leaves your body. Do not spiral. Do a short, slightly unglamorous sequence.

  • Stop using that secret. Rotate the password, revoke the key, invalidate the session. This is the only step that closes the door for good.
  • Delete the chat if the product lets you, and empty any "recently deleted" pocket if it has one.
  • Check connected apps and memory. Some tools keep snippets in memories or project files you forgot you enabled.
  • Tell the right person if it was work data. Security, a manager, a client lead; whoever owns the blast radius. Early is less painful than discovered later.
  • Watch for unusual logins on the related accounts. Rotation without monitoring is half a job.

If it was someone else's data, you also owe them a clean-up and, depending on the mess, a heads-up. Awkward. Still better than hoping the universe is polite.

Do not try to "overwrite" a leak by pasting more explanation. Extra context is extra copy. Get out of the thread.

Putting it together

The short version of What You Should NEVER Put Into AI is not a scolding list. It is a posture. If it unlocks a system, identifies a person, or would make you wince in a cafe, it stays out of the box. You can still get great help. You just feed the model a sketch, not the house keys, the medical file, and the neighbor's mail.

Quick recap:

  • No passwords, keys, tokens, or seed phrases. Rotate if you slipped.
  • No real IDs, full financials, raw health records, or NDA material.
  • No other people's private details, especially kids.
  • Screenshots lie by inclusion; crop like you mean it.
  • Redact, dummy, and ask for methods. Specific problem, fake labels.
  • Assume history lingers. Delete, do not archive secrets in a chatbot.
  • Workplaces need a short rule and a good example, not a mood of casual privacy.

Use the tools. They are excellent at drafts, debugging shapes, and talking you down from a confusing error. Just stop treating the text box like a vault with a sense of humor. It is a very smart blender. You still should not put your passport in a blender. 🫡

Practical example: Building a redaction-first debug brief for a small eng team

Privacy rules stick when they save an ordinary Tuesday, not when they sound stern. Here is how a five-person UK SaaS team used the habits in this guide to stop dumping credentials and customer PII into consumer chatbots - without giving up debugging help.

Scenario

Dev and support share one painful habit: when an auth error looks ugly, someone pastes the whole log, a staging connection string, and a screenshot of the admin dashboard "so the model has context." Last quarter that included a live-looking API key in a stack trace and a customer email still visible in the URL bar of a screenshot. Nobody meant harm. Speed won. The kitchen kept a recording.

They do not need a lecture. They need a repeatable brief: describe the secret by type, redact with placeholders, crop screenshots, ask for a method not a memory, then apply the fix on live systems offline. Consumer chat still earns its keep. The house keys stay out of the blender.

The goal is the same quality of advice with a two-second pre-paste scan - and a short team rule people will follow.

What the assistant needs

  • A sanitized problem shape: error class, roughly when it started, environment (staging vs production) without hostnames that map the network
  • Dummy inputs only: REDACTED_KEY, USER_TOKEN, customer@example.com, fake request IDs
  • What was already stripped (stated in the prompt so the model does not ask for the true values)
  • Desired output: likely causes, checks to run, a patch outline - not "connect with my key"
  • A human who keeps credentials in a password manager or secrets vault
  • A one-page team rule: no credentials, no customer PII, no unreleased figures, redact by default

Example instruction

Goal: Help me debug an intermittent 401 on our staging API after a token refresh. Do not ask me to paste secrets.

Constraints: I have already redacted passwords, API keys, tokens, cookies, internal hostnames, and customer emails. Placeholders in the log mean the true values exist only on my machine. UK English. No preamble.

Dummy excerpt: Request to https://api.example-staging.invalid/v1/session returned 401. Header Authorization: Bearer REDACTED_KEY. Body mentions USER_TOKEN expired. Screenshot description (not attached): error toast only; bookmark bar and account switcher cropped out.

Task: List the three most likely causes for this error class, the checks I should run locally, and a minimal patch outline. If you need more detail, ask for a type of information (e.g. "token TTL setting") - never for the raw secret.

Output: Numbered causes, then a checklist, then "what not to paste next time" in three bullets.

How to test it

  • Compare an old-style paste (full log + screenshot) with the redacted brief above on the same incident type. Compare advice quality and whether the model requests secrets.
  • Pre-paste scan: search the draft for @, long random strings, and numbers too long to be casual before send.
  • Edge case: include a fake key that looks genuine and confirm the reply still works without needing the true value.
  • Edge case: refuse a screenshot upload; retype the error line only; confirm the checklist still helps.
  • Acceptance checks: (1) zero credentials in the thread, (2) zero customer contact details, (3) placeholders declared, (4) output is a method/checklist not a "paste your key" flow, (5) if anything leaked earlier, rotation happened the same day.

Result

Illustrative result (example estimate for one small eng/support team, not a published study): Across 12 debug chats in four weeks, median time to a usable checklist rose slightly from about 4 minutes (full paste) to about 6 minutes with redaction - two extra minutes for the pre-paste scan and placeholders. Threads containing critical data types (keys, customer emails, raw connection strings) fell from 9 of 12 chats to 1 of 12 (that one was caught in review and rotated the same day). On a simple hygiene checklist (no secrets, no customer PII, placeholders declared, cropped or no screenshot), 11 of 12 redacted briefs passed versus 3 of 12 under the old habit. Limitations: small sample, one team, self-reported timing; milder incidents need less redaction; "pass" was peer review of the prompt text, not a lab audit of vendor logs.

To measure your own version: sample 10 recent AI debug threads for forbidden data types, then sample 10 after a redaction rule and template; report counts with denominators, plus median minutes from "stuck" to "checklist in hand."

What can go wrong

  • Screenshot smuggling: The error is fine; the URL bar still holds a token. Crop twice, then check the edges.
  • "Just this once" keys: A single leaked API key can open billing and customer records. Rotate immediately; do not wait to "see if anything happens."
  • Other people's data: A customer complaint with a phone number is not yours to donate to a model. Summarise in your own words.
  • Chat as vault: Leaving secrets in history creates another copy. Delete the thread after you move the bits you need to a local note.
  • Enterprise theatre: An approved workplace tool helps with retention; it does not make pasting crown jewels wise.
  • Skipping rotation after a slip: Deleting the chat without revoking the key leaves the door open.

Practical takeaway

What you should never put into AI is less a scolding list and more a posture: if it unlocks a system, identifies a person, or would make you wince in a cafe, it stays out of the box. Feed the model a sketch with placeholders, keep credentials in a vault, and ask for methods you apply offline. That two-second pause is how a helpful intern with infinite coffee stops becoming a filing cabinet for your house keys.

FAQ

What should you never put into AI chatbots?

If it unlocks a system, identifies a person, or would make you wince in a cafe, keep it out of the box. That includes passwords, API keys, tokens, seed phrases, government IDs, raw health and financial records, NDA material, and other people's private details - especially kids. Chat is not a locked drawer; text can be stored, processed, and sometimes used for training depending on the product and settings. Feed the model a sketch with placeholders, not the house keys.

Why do people paste secrets into AI even when they know better?

Speed does most of the work: an ugly error makes the whole log feel faster than stripping it down. Chatbots also feel non-judgmental, so privacy instincts take a tea break. The model usually needs the shape of the problem, not names, tokens, account numbers, or faces in screenshots - those are garnish. A two-second pause beats a personality transplant.

Is it safe to paste passwords or API keys into ChatGPT-style tools?

No. If it can unlock something, it does not belong in a prompt - passwords, one-time codes, session cookies, SSH keys, connection strings, wallet seeds, or private certificates. A model cannot keep a secret like a friend; text still travels, gets logged, and may sit in history. Describe the secret by type, use placeholders like REDACTED_KEY, rotate anything already leaked, and keep real credentials in a password manager or vault.

What personal information should I redact before prompting?

PII stacks fast: national IDs, passport details, addresses, phone numbers, employee or student IDs, and full names paired with dates of birth or clinics. The model does not need a real postcode to draft a letter - it needs tone, non-identifying facts, and the outcome you want. Swap names for roles, generalize locations, and drop unique numbers unless you are testing format with a fake example.

Can I paste client files, NDAs, or internal code into a consumer AI tool?

Treat consumer chat like a convenience product, not company counsel. If you would not put it in a personal Gmail draft or say it in a rideshare, do not put it in a public AI chat - client decks, unreleased roadmaps, salary sheets, confidential legal drafts, or source with internal hostnames. Describe the document, paste a sanitized excerpt, ask for a structure you apply offline, and use an approved workplace tool if you have one while still redacting by default.

How should I handle health or financial details in AI prompts?

Ask excellent questions without the raw record. General explanations beat pasting lab panels, prescription lists, insurance IDs, bank statements, or card photos that also capture the kitchen table. Strip account numbers and anything that looks like a credential. Use chat for framing and checklists to take to a professional - not as your clinician, accountant, or filing cabinet for statements.

Why are other people's data and screenshots especially risky?

You are not the only person in the paste: colleague emails, customer phone numbers, kids' photos, or call transcripts can land in a system without their consent. Summarize in your own words, replace names with roles, and never paste children's identifying details for "fun" generation. Screenshots smuggle bookmark bars, URL tokens, Slack names, and open tabs - crop twice, blur identifiers, or retype the error instead of uploading passports or cards.

What safer prompting patterns still get solid AI answers?

Be specific about the problem and stingy about identity: goal, constraints, dummy inputs, desired output. Placeholder unique labels, ask for a method rather than a full production log, split the task so you fill sensitive bits yourself, and use synthetic examples. Run a pre-paste scan for @ signs, long random key-like strings, oversized numbers, and names you would not put on a slide. Ten seconds pays rent forever.

What if I already pasted something awkward into an AI chat?

Stop using that secret first - rotate the password, revoke the key, invalidate the session. Delete the chat if the product allows, check memories or project files, tell the right person if it was work data, and watch for unusual logins. If it was someone else's data, clean up and give a heads-up when needed. Do not "overwrite" a leak with more explanation; extra context is extra copy.

How can a small team stop dumping credentials into AI for debugging?

Use a redaction-first brief: describe secrets by type, dummy logs with REDACTED_KEY and example emails, state what was stripped, and ask for likely causes plus a checklist - not "connect with my key." Add a short human rule - no credentials, no customer PII, no unreleased figures, redact by default - and show one good sanitized example. Keep real credentials in a vault and apply fixes offline after the model suggests a method.

References

  1. NCSC — ncsc.gov.uk
  2. OpenAI — help.openai.com
  3. OpenAI — openai.com
  4. Claude — privacy.claude.com
  5. Google Workspace — knowledge.workspace.google.com
Quiz
1. According to the article, what should you never put into a public AI chat?

2. What does “secrets stay offline” mean in this guide?

3. How should you strip identity before prompting?

4. What should stay out of consumer chat for work confidentiality?

5. Which habit matches the article’s consent and redaction advice?


Articles you may like to read after this one:

🔗 Top AI Security Tools
Discover powerful AI security platforms that detect and mitigate cyber threats.

🔗 Why AI Sometimes Makes Things Up
Understand why AI hallucinates and learn how to reduce the risks.

🔗 How to Automate Tasks with AI
Implement safe automation workflows by adding human oversight and strict rules.

🔗 What is AI Technology?
Explore the fundamentals of artificial intelligence and its common implementation challenges.

Back to blog