Why not just use AI for this?

Nobody needs another page claiming AI is bad. It is not. It is a general tool aimed at a specific job here, and the mismatch shows up in ways that only become obvious after you have lost an afternoon to it.

The job is narrow: find the code inside a document and colour it, without touching anything else. That is a recognition problem with a right answer, not a writing problem. What follows is what changes when you solve it with an algorithm instead of a model.

Part 1: what happens to your document

1. It edits your file. It does not retype it.

This is the biggest difference and the one people underestimate. A language model cannot hand you back a .docx. It hands you back text, and you rebuild the document yourself — fonts, headings, spacing, page breaks, tables, figure numbers, the lot. A forty-page specification becomes an afternoon of re-formatting.

Ask for the format you came in with here and the original file is edited in place. Every paragraph that is not code keeps its original bytes: the same font, the same point size, the same spacing, the same style, because those parts of the file are never rewritten at all. Nothing has the opportunity to drift.

2. Your words come back as your words

Models paraphrase. It is what they are for. Ask one to reformat a document and you will find sentences tightened, a heading reworded, a bullet list "improved", an inconsistency helpfully resolved. Most of the time you will not notice, which is the problem — you are now shipping a document you did not write and have not read.

A detector has no opinion about your prose. It classifies lines and colours some of them. The characters are the characters you gave it.

3. It does not invent code that was never there

Hallucination in a chat window is an annoyance. Hallucination inside a document you are about to submit or publish is a different thing entirely. Models fill gaps: a truncated listing gets a plausible closing brace, a missing import appears, a variable gets renamed to something more sensible, an ellipsis in the original is expanded into lines that never existed.

An algorithm cannot do this. It has nothing to generate with. The worst it can do is put the wrong label on a line that was already in your file — and it tells you which lines those probably are.

4. Length is not a problem

Every model has a context window. A long document has to be cut into chunks, and the chunks do not agree with each other: the same construct gets treated as code on page four and as prose on page thirty, because by page thirty the model can no longer see page four. You end up stitching the pieces together and reconciling them by hand.

There is no window here. A three-hundred-page document is read in one pass, and a decision made at the end is made with the same information as one made at the start. The whole file gets one consistent treatment.

5. The same document always gives the same result

Run a prompt twice and you get two slightly different answers. That sounds harmless until you re-export a document a week later and it no longer matches the version your colleague has, or you correct a mistake and the correction evaporates on the next run.

This is deterministic. The same file produces the same output today, next month and on someone else's machine. If you are formatting a series — a set of lab handouts, a course pack, a document that gets revised for years — that is the difference between a house style and a lottery.

6. It fails visibly instead of confidently

This one deserves more attention than it gets. When a model is unsure, it does not sound unsure. Every line comes back in the same fluent, assured voice whether it is right or wrong, and there is no way to ask it which parts to double-check that you can actually trust.

Here, every single line carries a confidence figure, and a control in the toolbar jumps straight to the least certain ones. On a typical document that is a handful of lines out of hundreds. You check those, you fix the two that are wrong, you are done — instead of proof-reading the entire file because any part of it might be quietly mangled.

7. You are still the author

Universities and employers increasingly require you to declare AI assistance, and some coursework rules prohibit passing your own submission through a model at all. Running a document through a formatter is not authorship assistance in any sense that those policies mean — nothing was written, suggested, corrected or improved for you. It is the same category as changing the font.

That distinction is worth having on paper, and it disappears the moment a model touches the text.

Part 2: what it costs you

8. One drop instead of six prompts

The realistic chatbot workflow is not one prompt. It is: paste, get a result with the comments left as prose, explain that, get a result that also swallowed the paragraph above, explain that, get a version where the output of the program is coloured as if it were source, explain that, and eventually copy something usable into Word and spend twenty minutes putting the formatting back.

Here the interaction is: drop the file, look at it, fix anything that looks wrong by selecting it, download. The corrections are two clicks, not a paragraph of English, and they apply to the actual output rather than to a request for a new one.

9. It is faster, and not by a little

A model generates its answer one token at a time, and it has to reproduce your entire document to give it back to you. A long file takes minutes of streaming, if it does not time out. Detection reads the whole document in a fraction of a second and the result is on screen before you have finished scrolling.

10. Free, and meant to stay that way

Good results from a model mean a good model, and good models are the paid ones. Free tiers throttle, queue, downgrade you to a smaller model at busy times, and cap how much you can upload. Meanwhile the compute the industry is buying is getting more expensive, not less, and the direction of travel for pricing is not subtle: things that were free are becoming metered, including simple ones.

This tool costs a fraction of a cent of compute per document, because recognising a pattern is cheap and generating a document is not. There is no account, no trial, no per-page charge and no tier that unlocks the good version. That is a promise the economics can actually keep.

11. The output is yours to shape

Ask a model for "a different theme" and you are negotiating. Here you pick from eleven IDE themes, choose a code font or supply your own font file, turn line numbers on or off, and re-mark any line as code, terminal output, equation or plain text. Every one of those choices flows straight into the PDF and the Word file.

The result also does not look generated. AI-formatted documents have a recognisable sameness — the same spacing, the same fenced blocks, the same flattened structure. Your document keeps its own layout, because its own layout was never taken away.

Part 3: what it costs everyone else

12. Your document is not training data

On the consumer tiers of the major chat products, what you upload may be used to improve the model unless you find the setting and turn it off. Business and API tiers generally exclude that by contract, but most people are not on those, and a document pasted into a chat window at eleven at night is not a document anyone checked the retention policy for first.

Here the file is sent over HTTPS, held in memory, and deleted — within twenty minutes of your last action, or the moment you close the tab. It is never written to disk, never passed to a third party, and never used to train anything. The privacy page spells out exactly what happens and where.

The one exception is opt-in and narrow. Refine output with AI sends only the specific lines the detector flagged as doubtful — not the file, not the document — to Google's Gemini API, and only when you press it. If your document is confidential, do not press it.

13. It uses a rounding error of the energy

A large model inference is a lot of arithmetic across a lot of accelerators, and those accelerators are power-hungry and, in most data centres, water-cooled. Precise per-query figures are contested and vary enormously by model and provider, so no number is quoted here. What is not in dispute is the ratio: pattern recognition over a few thousand lines of text is arithmetic a laptop would not notice, and generating an entire document token by token is not.

Using the small tool for the small job is not a moral position. It is just correct engineering, and the environmental part follows from it for free.

14. It is built for people, not for models

A quiet thing has happened to the web: an enormous amount of software now exists to feed models, be sold to model companies, or wrap someone else's model in a subscription. This is a small deterministic tool that does one job for a person who has a document in front of them, keeps that document private, and asks for nothing. There is a case for those continuing to exist.

Part 4: where an AI model is the better tool

Being honest about this is the point of the page. Use a model, not this, when:

• You need the code understood, not recognised. Explaining an algorithm, translating it into another language, finding a bug, writing the missing function — a detector has no idea what your code means and never will.
• Your PDF is a scan. If the pages are photographs there is no text to extract, and a vision model can read them where this cannot. Run OCR first, then come back.
• You want the document itself rewritten. Summarised, restructured, translated, made shorter. That is a writing job and a model is genuinely good at it.
• The content is unusual enough that recognition fails. Pseudocode, a language nobody has heard of, a listing typeset as a picture of a table. Rules have edges; a model's judgement degrades more gracefully than a rule does.

That last case is exactly why the AI review button exists. The right division of labour is not "algorithm or model" — it is algorithm for the ninety-nine per cent that is unambiguous, model for the handful of lines that genuinely are not, and only with your say-so. That is cheaper, faster, more private and more accurate than handing the whole document to either one of them.

Try it against a chatbot

The fair test is your own document, not ours. Take a file you have already tried to fix by hand, run it through both, and compare three things: whether the prose came back unchanged, whether anything appeared that you did not write, and how long it took to get to something you would actually send.

Open the highlighter