Before getting into how to use large language models well, it is worth correcting two assumptions that lead most business leaders in the wrong direction from the start.

Both of these misunderstandings have practical consequences. If you believe LLMs reason, you will trust their outputs in situations where pattern-matching fails and be surprised when they confidently produce plausible nonsense. If you believe a working demo signals production readiness, you will underinvest in the engineering, testing, and evaluation that separates a useful tool from an unreliable one.

Getting the model right in your head (what it actually is, not what it is marketed as), is the prerequisite for using it well. Everything else in this post follows from that.

The New Coworker: A More Useful Mental Model

The most practical way to think about an LLM is as an extraordinarily capable colleague who knows everything in general and nothing about you specifically. Frontier models can now hold vast amounts of context within a single conversation (enough to reason over an entire document library in one session), but they arrive at each conversation without any built-in knowledge of your business, your priorities, or how you work. The better your prompt at supplying that context, the more useful the output.

This framing of AI as a new coworker rather than a search engine or a magic oracle, changes how you interact with it. You would not walk up to a new colleague and say 'write me a report'. You would give them the context they need: who you are, what the report is for, who will read it, what it should contain, and how long it should be. The more specific and structured that briefing, the better the output. LLMs are identical in this respect.

The quality of your output is determined almost entirely by the quality of your input. Prompt engineering is the discipline of getting that input right.

The Four Building Blocks Of A High-Quality Prompt

Most people interact with LLMs the way they use a search engine: short, vague queries that expect the model to infer what they actually want. That approach produces mediocre results. A high-quality prompt is structured around four elements that give the model what it needs to produce work-quality output.

▲ An annotated prompt showing the four building blocks in context: Role, Task, Constraints, and Output Format. The structure does not need to be rigid, but all four elements should be present.

The role element is the most consistently underused. Telling the model who it is and not just what to do, changes the frame of reference for everything that follows. A senior marketing strategist reviewing a campaign brief will produce a materially different analysis than an unnamed assistant asked to 'review this'. The model draws on different parts of its training, adopts a different register, and applies different standards.

The constraints element is equally important and almost always absent from casual prompts. Constraints are not just restrictions; they are clarifications. Telling the model what to avoid ('do not use jargon', 'do not soften criticism diplomatically') is often more valuable than additional instruction about what to include.

Two Patterns Worth Building Into Your Workflow

Of all the prompting techniques I have used across my builds, two have become consistent defaults, not because they are the most sophisticated, but because they reliably improve output quality across a wide range of tasks.

▲ ROCOF (Role · Objective · Constraints · Output Format) and Critic → Improve, two patterns that address different failure modes. ROCOF structures the input; Critic → Improve structures the thinking.

ROCOF: Role, Objective, Constraints, Output Format

This pattern is the four building blocks applied as a consistent template. The value of making it a template and not just a principle, is speed and reliability. Once you have built a ROCOF prompt for a recurring task (weekly report analysis, campaign brief review, content summarisation), you can reuse and refine it rather than starting from scratch each time. The structured input becomes an asset.

Critic → Improve: Iterative Self-evaluation

Instead of asking the model for a single answer, force it into a loop: generate a response, then critique it, then challenge the critique, then rewrite. This pattern addresses the LLM's tendency toward confident, surface-level outputs. When you ask a model to identify the weaknesses in its own answer, it frequently finds them. The revised output is almost always materially better than the first.

The pattern can be applied in a single prompt ('Draft a response. Then identify its three weakest points. Then rewrite addressing each.') or as a multi-turn conversation. Both work. The multi-turn version tends to produce slightly better critiques because the model is not trying to hold too many instructions at once.

Meta-Prompting: AI Building AI

The insight that genuinely changed how I approach prompt engineering was not a specific technique; it was a concept. The realisation that you can use AI to build better prompts before the real task even starts. I think of it as the Inception principle: a layer of AI whose only job is to optimise your input to the layer of AI that does the actual work.

▲ Meta-prompting in four layers: the human describes an intent, a prompt-optimising AI restructures it, the refined prompt goes to the task AI, and the output is materially better than the original description would have produced.

In practice this means: before asking an LLM to write a strategy document or analyse a dataset, first ask it to help you build the best possible prompt for that task. Describe what you want in plain language and ask the model to turn that description into a ROCOF-structured, high-precision prompt. Then use that optimised prompt for the actual task.

The compounding effect of this approach is significant. You benefit from the model's knowledge of its own behaviour as it knows what kinds of instructions produce better results, without needing to develop that expertise yourself through trial and error. It is AI for AI: using the tool to sharpen the tool.

You do not need to be a prompt engineer to get great prompts. You need a prompt engineer to build your prompt engineer. That prompt engineer is the same model you are already using.

When Standard Prompting Is Not Enough

For most business tasks like drafting, summarising, analysing, structuring a well-built ROCOF prompt will produce reliable output. For higher-stakes tasks where the cost of an error is significant, three additional techniques are worth knowing.

▲ Chain of Thought, Chain of Verification, and Reasoning Models, three techniques for tasks where standard prompting underdelivers. Each addresses a different failure mode.

Chain of Thought is the simplest upgrade available in which you add the 'think step by step before answering' to any prompt that involves multi-step reasoning. It works because it forces the model to externalise its logic sequentially rather than jumping to a conclusion, which catches more errors in the process. The cost is near-zero; the reliability gain is consistent.

Chain of Verification is the structured version of Critic → Improve, applied specifically to factual outputs. The model drafts a response, generates verification questions about that response, executes those checks against its knowledge, and then produces a revised final answer. For any output where hallucination is costly like research, technical analysis, recommendations with cited evidence etc., this four-step loop reduces error rates significantly.

The model selection point is worth emphasising because it is frequently ignored. Standard conversational models like GPT-4o, Claude Sonnet, Gemini Flash, Llama 3 etc. are optimised for dialogue, summarisation, and text generation. Reasoning models like OpenAI's o-series, DeepSeek R1, Claude's extended thinking mode on the other hand are built specifically for planning, multi-step logic, and complex problem-solving, and carry higher cost per call.

Using a reasoning model for routine conversation is unnecessary and expensive. Using a standard model for complex strategy work underserves the task. Matching the model class to the task type is itself a form of prompt engineering and one of the highest-leverage decisions you can make before writing a single word of your prompt.

The Demo-to-Production Gap: Why It Matters

The second misunderstanding that a working demo signals production readiness, deserves its own section because it is where the most expensive mistakes happen.

A demo is a best-case scenario. The inputs are clean, the query is well-formed, and the person running the demo knows what to ask. Production is the full distribution of real inputs: ambiguous questions, incomplete information, edge cases, and users who interact with the system in ways you did not anticipate. The LLM that performed flawlessly in testing encounters all of these without warning.

The gap between demo and production is primarily an engineering problem, not a prompting problem. It requires: evaluation frameworks that test the system against a diverse set of inputs including adversarial ones; error handling for cases where the model refuses, hallucinates, or produces malformed output; feedback loops that capture real-world failures and drive prompt iteration; and honest assessment of which tasks the model handles reliably versus which require human review.

None of this is visible in a demo. All of it determines whether an AI tool creates commercial value or creates liability. The teams that build reliable AI systems treat the demo as the beginning of the work, not the end of it.

Build Your Prompt Playbook

The most practical takeaway from everything in this post is not any individual technique, but it is the habit of iteration. Every prompt that produces an unexpectedly good or bad result is information that still needs review. The difference between someone who gets mediocre outputs from AI and someone who gets excellent ones is not talent; it is the discipline of noticing what worked, saving it, and refining it over time.

A personal Prompt Playbook, even just a running document with your best-performing prompts organised by task type, compounds in value over months.

ROCOF templates for your most frequent tasks.

Critic → Improve patterns for the outputs where quality matters most.

Meta-prompting for tasks you only do occasionally but want to do well.

And a growing sense of which tasks are genuinely better with AI, which require careful oversight, and which are still faster without it.

To get you started, a library of six ready-to-use prompts (one for each technique covered in this post) is included in the Prompt Starter Kit at the end.

That last distinction of the honest assessment of where AI adds value and where it does not, is the mark of an AI generalist rather than an AI enthusiast. The goal is not to use AI for everything. It is to use it well where it matters.

Prompt Starter Kit: Six Templates Worth Saving

The techniques in this post are only useful if you actually use them. What follows is a working prompt for each method covered, written for business contexts common in the GCC region. Treat these as starting points. The value compounds when you adapt them to your specific tasks, save what works, and build from there.

1. ROCOF: Vendor Or Supplier Evaluation

Use when comparing proposals, evaluating a shortlist, or preparing a procurement recommendation for a senior stakeholder.

You are a procurement specialist with experience evaluating technology and service vendors in regulated, multi-market environments.Review the following vendor proposals and evaluate them against the criteria listed below: [insert criteria, e.g. cost structure, delivery capability, regional presence, SLA terms, implementation risk].Do not recommend a vendor you cannot substantiate from the information provided. Flag any gaps in the proposals that prevent a complete assessment. Be direct about weaknesses; do not soften them.Format your response as: a comparison table with vendors as columns and evaluation criteria as rows; a one-paragraph recommendation identifying the preferred vendor and your primary reason; one sentence identifying the main risk of that selection.Here are the proposals: [paste]

2. ROCOF: Preparing An Executive Briefing

Use before any leadership meeting where you need to translate performance data into a clear, decision-ready summary.

You are a senior business analyst with experience preparing concise executive briefings for C-suite and board audiences.Review the following performance data and prepare a briefing summary for a leadership meeting. [paste data or context]Cover the top three wins, the top three concerns, and one recommended action per concern. Do not use internal jargon. Flag any metric that appears inconsistent or requires clarification. Do not soften underperformance: the audience needs an accurate picture, not a managed one.Format your response in three sections: Wins, Concerns, Recommended Actions. Each section: maximum three bullet points, one sentence per bullet. Total response: no more than one page.

3. Critic → Improve: Strategy Document Or Proposal Review

Use when you have a draft document (a strategy, a proposal, a plan) and want a structured second opinion that challenges the thinking rather than polishing the language.

I am going to share a draft document. Work through it in three stages: do not skip any stage.Stage 1, Critique: Read the document and identify the top three strategic risks. These should be assumptions that could prove wrong, dependencies that could fail, or gaps in the logic. Be specific; name the exact claim or section you are challenging.Stage 2, Challenge your own critique: Review Stage 1 and identify the two weakest points in your own analysis. Where could you be wrong? Where is the critique shallow or easy to dismiss?Stage 3, Final critique: Rewrite the critique from Stage 1, strengthening the weak points and removing anything that does not hold up. The final version should be direct enough that someone reading it would know exactly what to fix.Here is the document: [paste]

4. Meta-Prompting: Build A Reusable Prompt For A Recurring Task

Use this before starting any task you will repeat regularly. Let the model build the prompt once; reuse it every time.

I need to [describe the task in plain language, for example: ‘prepare a weekly update for our regional general manager summarising commercial performance across three markets’].Before we do the task, I want you to help me build the best possible prompt for it that I can reuse.Ask me the clarifying questions you need: who the audience is, what format they prefer, what level of detail is appropriate, what they already know and do not need repeated, and any constraints I should set on tone, length, or content.When you have what you need, produce a complete ROCOF-structured prompt I can save and use each time. Do not start the task itself. Build and return the prompt only.

5. Chain Of Thought: Multi-Step Business Decision

Use for any decision where the reasoning matters as much as the conclusion: pricing changes, resource allocation, market entry, build-versus-buy.

Think step by step before reaching any conclusion. Do not jump to a recommendation until you have worked through each stage below.I am evaluating the following decision: [describe, for example: ‘whether to extend our distribution agreement with our current logistics partner in KSA or transition to a regional 3PL provider’].Here is the relevant context: [paste: current performance, contract terms, constraints, stakeholder considerations]Work through these stages in sequence:1. What are the key assumptions this decision depends on?2. What does the available information support, and what does it leave uncertain?3. What are the strongest arguments for and against each option?4. What would need to be true for each option to be the right choice?5. Given the above, what is your recommendation and what is the primary risk attached to it?Show your reasoning at each stage. Do not collapse stages or summarise early.

6. Chain Of Verification: Research Synthesis Or High-Stakes Recommendation

Use when the output will be shared externally, used to brief a decision-maker, or cited as evidence in a proposal.

I need you to [describe the task, for example: ‘summarise the regulatory and commercial risks of launching a fintech product in the UAE for a business currently operating only in Saudi Arabia’].Complete this in four stages. Do not collapse or skip any stage.Stage 1, Draft: Write an initial response to the task.Stage 2, Verify: Review what you just wrote and produce four specific questions that a careful reader might use to fact-check or challenge the response. Be specific: do not write vague questions.Stage 3, Check: Work through each question against what you know. Flag clearly where you are uncertain or where the original draft made a claim that does not fully hold up.Stage 4, Revise: Rewrite the original response incorporating what you found in Stages 2 and 3. Remove or qualify any claim you could not substantiate. The final version should be something you would be comfortable citing in a formal document.

Copy any of these into a document and adapt the bracketed sections to your task. The ones that work for your most frequent tasks are worth saving with your specific context pre-filled: role already set, format already specified, constraints already defined. That is the beginning of a Prompt Playbook.