Field Notes
The last post was about prompt engineering as job design.
A good prompt tells the model the job, the sources, the risks, the quality bar, and the stop sign.
That is useful when you already understand the work.
The harder problem shows up one step earlier.
You have a vague idea.
"I want AI to help with client onboarding."
"I want an agent to help with guest messages."
"I want a system that turns calls into follow-up."
"I want to use AI for content."
Those are real goals, but they are not clear jobs yet.
If you try to write the final prompt too early, the model has to build on a blurry foundation. It may still produce something polished. That is the trap. Polish can hide missing judgment.
The better move is to make the first prompt an interview.
Before the AI writes the deliverable, ask it to question you.
Before it drafts the email, builds the workflow, writes the SOP, analyzes the report, or creates the agent instruction, make it pull the missing shape out of your head.
That is the prompt before the prompt.
It sounds small. It changes the whole workflow.
Instead of asking AI to guess the job, you ask it to help define the job.
The first output is clarity.
Then the final prompt gets written from that clarity.
This is one of the easiest ways to make AI feel less random. The model stops trying to infer everything from a thin request. It gets to ask about the parts a good employee would ask about before starting.
What is the outcome?
Who is this for?
What sources should it trust? If there is more than one, which source wins? That is the sovereignty problem from Don't Single-Source Your Agent.
What decisions are allowed?
What decisions need review? Where should the model stop instead of pretending it knows? That is the guardrail from AI Lies When You Do Not Give It an Out.
What should happen if the data conflicts?
What would make the output dangerous?
What does done mean?
Those questions are not filler. They are the work.
They are how rough intent becomes an agent-ready instruction.
Playbook
Here is the practical version.
When you have a messy idea, start with a meta-prompt.
Do not ask for the final answer yet.
Ask for the interview.
Use something like this:
I want to use AI for [workflow].
Before writing the final prompt, interview me.
Ask one question at a time until you understand:
- the job,
- the audience,
- the source material,
- the output format,
- the risks,
- the edge cases,
- the definition of done,
- and where the AI should stop for human review.
Then write the final prompt as a reusable job description.
After that, critique the prompt and tell me what is still missing.That is enough to start.
The important part is the sequence.
Rough intent first.
Interview second.
Final prompt third.
Critique fourth.
That order matters because a model will usually try to be helpful immediately. If you ask for a prompt, it will write a prompt. If you ask for a plan, it will write a plan. If you ask for a draft, it will draft.
You have to slow the workflow down long enough for the missing context to become visible.
1. Start with the workflow, not the tool
Bad starting point:
"Write me a prompt for ChatGPT."
Better starting point:
"I want AI to help me turn a client call into a follow-up email, internal task list, CRM update, and next-call agenda."
The tool is secondary. The workflow is the thing you are engineering.
When you describe the workflow, include the real business motion:
- who triggers it,
- what information exists,
- what output should come back,
- what happens after the output,
- and what would create risk if the AI gets it wrong.
2. Make the AI ask one question at a time
One question at a time is underrated.
When the model asks ten questions at once, people answer the easy ones and skip the uncomfortable ones. The missing context survives.
One question at a time creates pressure.
It turns prompting into a conversation instead of a form.
The model can follow the thread. You can think. The workflow gets sharper with each answer.
3. Ask it to find the missing pieces
The best interview is not polite.
It should look for what you forgot.
Tell it to identify missing sources, vague terms, undefined approval gates, edge cases, private data concerns, and places where the task could accidentally become an external action.
For example:
"If I say 'follow up with the lead,' ask what they already know, what offer they came in through, what promises have been made, what should stay out of the email, and whether this is draft-only."
That is a stronger setup than asking for a beautiful email.
Beautiful can be wrong.
Specific can be reviewed.
4. Turn answers into a job description
After the interview, ask the model to write the final prompt as a reusable job description.
That final prompt should include:
- the job,
- the audience,
- the trusted sources,
- the source hierarchy,
- the output format,
- the tone,
- the risks,
- the examples,
- the stop signs,
- and the receipt you want back.
If it cannot write those pieces cleanly, the workflow is still underdefined.
That is useful feedback.
The interview did its job.
5. Make the model critique the prompt
This is the part that makes the workflow better fast.
After it writes the final prompt, ask:
"What could still go wrong if I used this prompt?"
Then ask:
"What would you add to make this safer, more specific, and easier to review?"
You are using the model to improve the instruction before the instruction is used.
That sounds circular until you try it.
The model is very good at spotting missing acceptance criteria, unclear source rules, vague words, and hidden assumptions once you ask it to inspect the prompt as an object.
6. Save the working version
When the prompt works, stop letting it disappear into chat history.
Save it.
Name it.
Give it a trigger.
"Use this after a paid consulting call."
"Use this before drafting any guest response."
"Use this for newsletter post development."
"Use this before changing a pricing recommendation."
That saved instruction is the beginning of a skill.
The first time you run the interview, you are learning the job.
The second time, you are improving the job.
The third time, you are building an operating system.
Orientation
Meta-prompting teaches two things at once.
It teaches the model what you need.
It teaches you what you forgot to specify.
That second part is the leverage.
A lot of AI frustration comes from invisible assumptions. You assume the model knows the business context. It does not. You assume it understands the source of truth. It may not. You assume it knows when to stop. It will keep going unless you tell it where the gate is.
The interview makes those assumptions visible.
That is why the prompt before the prompt is so valuable.
It turns the model into a question-asking assistant before it becomes a producing assistant.
It turns your rough idea into something structured.
It turns "help me with this" into a real job.
And once you have the job, you can build the rest of the system around it: context, tools, review gates, receipts, and eventually a repeatable workflow.
Try this with one workflow tomorrow.
Pick something you already ask AI to do.
Do not rewrite the prompt yet.
Ask AI to interview you first.
When it finishes, look at the final prompt it creates.
You will probably see the real lesson immediately:
The better prompt was hiding behind better questions.
Comment below with the workflow you would run through this interview first.
I read every one.
-- Brian