Your CV Can Hide Orders to Your AI Screener. Here’s How to Catch Them

Yesterday a clever check showed up on r/PromptEngineering. The twist is in step 2.

The team at Unsiloed AI shared a demo of a CV that looks perfectly normal on screen. But buried in the file is a 29-word instruction telling an AI screener to rank this candidate first. You can’t see it. Your agent can. If a recruiter skimmed that PDF, they’d see a clean, ordinary resume. If an agent ingests it, it also reads a quiet order to put this person at the top of the pile.

What’s new

The idea is simple. A PDF stores text in one place and shows a rendered page in another. Those two don’t always match. Unsiloed runs two parsing reads on the same document: one on the text layer stored in the file, and one on the rendered page as a human would see it. Then it compares them.

Think of it like proofreading a contract against a photocopy of the same contract. If the photocopy is missing a paragraph the original has, you want to know why. Most pipelines only ever do one read, so they never get the chance to notice the mismatch.

The twist

The hidden instruction shows up in the text-layer read. It’s missing from the rendered-page read. That gap is the signal. You don’t need a magic detector that “understands” prompt injection. You just need to notice that the file says something the page doesn’t.

That’s what makes this so practical. Detecting intent is hard and always will be. Detecting a difference between two reads is plain bookkeeping, and bookkeeping is something you can set up this afternoon.

The saved examples cover the usual tricks: white text, tiny text, covered text, off-page text, and text colored to match a sidebar. All of them hide from your eyes and stay readable to a model. A one-point font in the margin, a white paragraph on a white background, a text box sitting under an image: your eyes skip right past every one of them, and a parser picks them up without blinking.

The mini-workflow

  1. 🔍 Read the PDF’s text layer. This is what an agent would ingest. Pull it out as raw text and keep it exactly as the file stores it, including odd spacing and stray lines.
  2. 🖼️ Read the rendered page. This is what a person actually sees. Render each page to an image and run a read on that, so you only capture what is visibly on screen.
  3. ⚖️ Diff the two. Anything in the text layer that never appears on the page gets flagged. Normalize whitespace and casing first so you’re not chasing noise, then look for whole sentences or long phrases that exist on one side only.
  4. 👀 Send the flagged passage to a human reviewer before the document goes anywhere near your agent.

The reviewer doesn’t have to hunt through the whole file. They get one specific passage to look at. A good flag says something like “page 1, 29 words, not visible in the render,” and the reviewer can decide in ten seconds whether it’s a real problem or a quirk.

Pro tips

  • Treat this as a review check, not a complete prompt-injection detector. The author says so plainly, and that’s the right way to use it.
  • Expect some false alarms. OCR differences can create mismatches that aren’t malicious. Setting a minimum length, say a full sentence or more, before something gets flagged will cut most of that noise.
  • The reverse also holds: an instruction can be fully visible on the page and still be an injection. A diff won’t catch that one, so keep your normal review in place.
  • One commenter pointed out you can do a basic version of this deterministically at zero token cost, and that a coding assistant can put it together fast. If you only need the quick check, that’s a fair weekend build. The Unsiloed route is there if you’d rather not maintain it.
  • Log every flag you get, even the false alarms. After a couple of weeks you’ll see which patterns are harmless and which deserve a closer look.

Why I like it

Most of us assume a PDF holds what’s on the page. It doesn’t have to. If you’re feeding resumes, contracts, or invoices into an agent, that assumption is an open door. This check closes a good chunk of it with very little effort. It also costs almost nothing to run, which matters when you’re processing documents in bulk.

Your move

If any agent of yours reads documents from strangers, add a text-layer vs rendered-page diff before it reads them. Parsing modes and configuration are in the Unsiloed docs: https://www.unsiloed.ai/docs/document-processing/parsing/processing-modes

Demo GIF from the original post: https://i.redd.it/24p2bq0m7rzh1.gif

Go test one of your own PDFs and see what’s hiding in it! 🏴‍☠

Frequently Asked Questions

Q: Where do hidden instructions usually sit in a PDF?

The common spots are white or near-white text on a white background, very small font sizes, text placed behind an image or box, text positioned off the visible page, and text colored to match a sidebar. A person looking at the page never sees any of it, but a parser that reads the raw text layer picks it up. That’s why the check compares the two views instead of trusting either one alone.

Q: Do I need an AI tool to catch this, or can I build the check myself?

Commenters disagree here. One says the core check is deterministic, so you can build it in a weekend at zero token cost by extracting the PDF’s text layer and comparing it to the text on the rendered page. Another commenter was skeptical that the approach is worth paying for. The post itself notes that OCR differences can cause false alarms, so a homemade script will need to handle that too. A practical path is to start with a plain script on your own files and only look at hosted tools if the noise gets in your way.

Q: Does a mismatch mean someone is trying to game the screening?

Not necessarily. OCR differences, fonts, and headers or footers can all produce mismatches, and an instruction can be visible on the page anyway. Treat each flagged passage as something to look at, not as proof of an attack. Read the flagged text next to the rendered page and decide whether it’s a formatting quirk or something the candidate wrote on purpose.

Q: Is a visual review enough if a human is reading every CV?

One commenter put it well: it’s easy to assume a PDF only contains what’s visually on the page, and that assumption is exactly what hidden text exploits. A rendered-page review shows what a person sees, not everything a parser reads. If your pipeline feeds PDFs to an AI, the text layer is what the model actually gets, so that’s the layer worth checking.

A CV can contain instructions you can’t see on the page
by u/Unsiloed-AI in PromptEngineering

Scroll to Top