If everyone uses the same model, then everyone also has the same prompts and gets similar results — because the model is exactly the same for everyone. So the edge isn't the model. The edge is the context you feed it: your taste, your way of speaking, your decisions. The trouble is that this context sits in your head and stays there. I'll show you a method that draws it out — by interrogation, point by point, into a lasting document the model can draw on later.
Why context is the real lever
The vocabulary first, because the whole piece revolves around three terms.
Context is everything you give the model alongside the instruction: the background to the matter, your rules, earlier decisions, examples of how something should look. It's the difference between "write a proposal" and "write a proposal the way I do it — in this tone, within these bounds, for this type of client." The model itself is widely available. The context only you have.
A skill is a small, named capability the model runs on demand. It sounds technical, but in its simplest form a skill is just a prompt you don't want to type out from scratch every time. It needn't be a complicated automation. It can be five sentences that you word well once and then call up with a single command.
The context window is the amount of text the model "sees" at once during a single conversation: the instructions, the files, the whole exchange so far. It has a limit. As it fills, the model starts losing what was said at the start — and that's at the heart of one of the problems we'll solve below.
From this comes a simple observation. Since the model is a commodity, the quality of your results depends on the quality of the context you supply it. And the hardest, most tedious part of the whole job isn't writing prompts. It's extraction — moving what you know from your head into the system, so your skills and everything else can draw on it.
The interrogation method: one question at a time
The typical instinct goes like this: you sit down, spend five minutes pouring out everything that comes to mind, and hope that's enough. It never is. A memory dump skips the dozens of small decisions you don't even notice, because to you they're obvious — and those are exactly what your context is made of.
A better method reverses the direction: instead of you saying everything, the model interrogates you. I call it an interrogation because that's exactly how it works. The instruction is short — a few sentences — and it tells the model to:
- question you persistently about every element of the plan or process, until the two of you arrive at a shared understanding of the topic;
- work along each branch of the decision tree in turn and resolve the dependencies between decisions one after another, rather than jumping around at random;
- ask one question at a time — not bury you under a list of ten that you answer cursorily;
- for each question, propose its own recommended answer, so you can accept it, amend it, or reject it, instead of starting from a blank page every time;
- and where the answer to a question is in the project files themselves — check it there on its own, rather than asking about something it can read anyway.
That last point matters. A good interrogation doesn't waste your time on things the system can establish without you. It asks only about what you genuinely have in your head alone.
In practice it looks like this: you start with a single sentence along the lines of "interrogate me about how I run this process." You get the first question and a recommendation. You answer, or accept the suggestion. The next question follows. And so on — sometimes five questions, sometimes thirty, sometimes the conversation stretches past an hour. Long is a good sign. You stop only once there are no more holes in the knowledge.
The same approach works more broadly than for a single skill. You can walk through a whole process this way, or the entire operating logic of a business — step by step, decision by decision — so the system genuinely understands how something works, rather than just having a general idea of it.
Checkpoints: why the model writes as it goes
Here we reach the refinement that, to my mind, decides whether the method is merely interesting or actually reliable. The interrogation method on its own has one weakness: if the conversation runs an hour or more, the context window fills up — and the model starts garbling your earlier answers. What you said at the start blurs under the weight of what came later.
The solution is checkpoints. After each answer, the model doesn't just move on — first it writes the answer to a document. A separate text file is created (most conveniently in plain markdown, in a single folder you can name something like "brainstorms") that grows along with the conversation. This way the knowledge no longer lives only in the fleeting context window — it has a lasting record on disk. Even when the window overflows, the decisions from the start of the conversation are safe, because they were written down before the model had a chance to forget them.
It's worth having such a document organize a few things:
- key decisions — the gist of what the two of you settled, ready to read at a glance;
- a question-and-answer log step by step — a full trail of the conversation you can return to;
- the most important takeaways — what really has to be remembered about the process;
- open flags — and this, to my mind, is the most valuable part.
Open flags are the things you yourself don't quite know. Sometimes you hit a part of the process you can't explain as precisely as the person who actually runs it. Rather than make something up or feign certainty, the system marks it: "check this with the right person, bring back the answer, and then we'll fill in the document." That's honest about reality — it admits not all the knowledge is in your head, and it says plainly where to go for it.
A finished document isn't a one-off. Since it's an ordinary file, you can return to it at any time. When the process changes or you find a better way of working, you run the interrogation again — "interrogate me once more, here's what's changed" — and refresh the record. And since you have the whole nuance of the conversation written down, you can, in the same move, ask it to update the related skills and instructions where that knowledge was missing before.
Sharpen the axe before you fell the tree
Why all this effort up front? Because it decides how close to the goal you start.
Nothing is good on the first attempt. The old way of building a skill goes like this: you do a hurried memory dump, assemble a first, mediocre version, and then laboriously improve it — iteration by iteration, each one a touch better, until after many, many attempts you arrive at something solid. That can be a dozen-odd rounds. It can be far more. And honestly, you never reach full perfection, because as the company changes and you change, the skill has to change too.
The interrogation shifts all that effort to the beginning. You invest it up front — in one thorough conversation instead of in hundreds of small fixes later. The effect is that, right from the first attempt, you start much closer to a credible result, instead of climbing your way there over a dozen iterations. It isn't perfect, and you'll still be refining things — but you're there far sooner, which gives you more room to look for genuinely better improvements, rather than patching the basics.
It's an old principle at heart: if I had six hours to fell a tree, I'd spend the first four sharpening the axe. Gathering context up front can feel dull and repetitive, because it shows no immediate result. But it's exactly this stage that pays back many times over later — in every subsequent run of a skill that knows from the outset how you think.
My conviction is simple: since you have the same model as everyone else, the only thing you can really sharpen is the context. And the cheapest way to sharpen it is to let the system interrogate you once, properly, and write down the answers before it has a chance to forget them. Pick one process you have in your head alone and ask: "interrogate me about this" — that's a good first entry for your knowledge folder.