For all the sophistication we’ve added to AI interaction, we’ve forgotten one of the most basic tools of collaborative work: the ability to point at something and say, “this.”
In the paragraph after the section about X, where you mention Y, the one after the example…
This is how we work with some of the most sophisticated AI systems ever built. We can ask them to write an article or refactor a codebase, then spend dozens of turns refining the result. The whole premise of AI chat is that useful work doesn’t have to happen in one shot. We can iterate, but when we want to change one specific thing, we have to describe where it is.
A red pen solved this problem a long time ago. You circle the sentence, cross out a word and write too strong in the margin. You don’t explain the coordinates of your criticism. You point and say: this.
Chat became a place to work
There’s nothing particularly wrong with this interaction model for regular chat. I send you a message, you send me one back, and perhaps I reply to a specific message when I need to make the connection explicit. The messages themselves are the thing we’re producing.
AI chat is different because the conversation increasingly produces something else: an article, some code, a research report, or a presentation. These things rarely emerge perfectly from a single prompt. We generate something, inspect it, add context and try again. AI chat has become an iterative working session, while its fundamental interaction model remains an exchange of messages.
Context and reference solve different problems
A lot of effort has gone into making these working sessions better. Models can handle increasingly large context windows. Conversations persist, while projects and workspaces give related conversations shared context. Generated output can sometimes live in a separate artifact rather than disappearing into the transcript.
All of this helps AI understand what we’re working on. It doesn’t necessarily help us tell it what we’re talking about. Context and reference are different problems.
If AI produces a 2,000-word draft and you disagree with one sentence, both of you have plenty of context. The draft is right there, along with the conversation that produced it. What you’re missing is reference, so you start navigating with words: the second paragraph under…, the sentence where you mention…, or the argument after the example about… Sometimes you copy the offending passage and paste it back into the conversation. The more substantial the output becomes, the more ridiculous this gets.
An artifact still needs pointing
Moving the output out of the chat helps. A separate document is easier to inspect and can remain stable while the conversation continues. When AI changes it, you can more easily see what changed.
But unless you can annotate that document and carry the annotation into the conversation, you still have the same problem. You can see the sentence you want to discuss. AI can see it too. Yet you still have to describe the sentence so that you both know you’re discussing the same thing.
Imagine working this way with another person. You’re sitting next to each other looking at a printed document and spot a problem halfway down the page. Instead of putting your finger on it, you carefully describe its location: No, lower. The paragraph beginning with “Increasingly.” Third sentence. The bit after the comma. Nobody works like that when pointing is available.
This also means not that
Precise reference does more than identify what you want to change. When you circle a paragraph with a red pen and write rewrite this, you also define what the other person should leave alone. The circle establishes a boundary.
That boundary matters when working with AI because regeneration is cheap. Ask for one change and you can easily get a fresh version of the whole thing. The paragraph you disliked is better, but something you liked three paragraphs earlier has subtly changed too. Now you have another job: compare the new version with the old one and make sure AI didn’t improve anything you didn’t ask it to improve.
Precise reference makes precise delegation possible. Change this carries an implicit instruction: leave that alone. Without that boundary, every small correction can turn into a review of the whole artifact.
Give me the red pen
The better AI becomes, the more important this problem gets. When AI produced a few paragraphs at a time, describing the part you wanted changed was manageable. Now we ask it to produce applications, specifications and increasingly substantial pieces of work. The artifact gets larger, the iteration gets more complex, and the cost of referring to one part of it using language keeps growing.
We’ve made enormous progress in what AI can produce and how much context it can remember. We’ve also improved how well it can understand what we tell it. But sometimes I don’t want to tell it where the problem is. I want to circle it with a red pen and say: this.