You are the operator. The AI is the instrument.
A comprehensive working manual for getting professional results out of ChatGPT, Claude, Gemini, and Microsoft Copilot, and for turning that skill into systems that run on their own. Teaching modules are written three ways: pick Beginner, Intermediate, or Expert in the bar above. Reference sections stay detailed at every level.
Orientation: what an operator is
Objective: understand the mindset that separates people who get leverage from AI from people who get frustrated by it, and how to read this manual.
Think of these tools as a fast, capable new coworker who has read almost everything but knows nothing about your job, your project, or your goal until you tell them. They are not a search box, and they are not magic.
The whole skill fits in one sentence: say clearly what you want, give the background it needs, and check the answer. Everything else in this manual is detail on those three moves.
One habit helps right away: the tool mirrors what you put in. A rushed, vague request gets a rushed, vague answer. A clear one gets a clear one.
And one warning matters more than any tip. These tools sound confident even when they are wrong. They can invent facts, numbers, and quotes that look completely real. Always check anything factual before you use it.
How to read this manual: the numbered modules change with the Beginner / Intermediate / Expert bar at the top. The reference sections (deep dives, templates, governance, glossary) stay detailed at every level, so you can consult them anytime.
- Did I say clearly what I want?
- Did I give the background it could not already know?
- Did I check the answer before trusting it?
Most people treat these tools like a search box, get a bland answer, and conclude the tool is overrated. An operator treats the tool like a fast, capable, slightly literal-minded colleague who knows nothing about the specific situation until told. That framing changes everything.
The three jobs you always have
- Direct. State the task, the audience, the format, and the standard. Do not make the tool guess.
- Supply. Give it the context it cannot know: your goal, your constraints, the source material, the voice you want.
- Verify. Read the output as a skeptic. Confirm facts, figures, and quotes before anything leaves your hands.
These jobs transfer across every tool. The four makers publish different frameworks with different names, but underneath they all say the same thing: be explicit, give context, show an example when it helps, and check the result. Module 02 teaches the shared discipline; Module 04 and the deep dives cover the per-platform differences.
What has changed is the surface. Today's assistants read intent well, carry memory across chats, run on a schedule, and act across your apps. The job has grown from asking better questions to designing small systems, which is what the automation and governance sections cover.
Read this first
These models generate confident text, and confidence is not accuracy. They can invent statistics, citations, names, and quotes that look completely real. Treat every specific factual claim as unverified until you confirm it against a primary source. This discipline gets more important, not less, once you automate.
Operating a model is a control problem. You are steering a high-variance generator toward reliable output at the lowest specification cost that still clears your quality bar. The three jobs compress into three levers: reduce ambiguity, inject private context the model cannot infer, and gate delivery on verification proportional to stakes.
Two disciplines separate operators at this level. The first is calibration: knowing which tasks need heavy specification and which a capable model handles from a terse prompt. Over-specifying a strong model wastes effort and can suppress good judgment; under-specifying a weak one guarantees drift. The second is context engineering: moving stable instructions out of individual prompts and into standing configuration, so each prompt carries only the task-specific difference. Your reusable setup becomes the product; the prompt becomes the delta.
A third discipline emerges once you automate: systems design. You stop optimizing single prompts and start designing pipelines with defined inputs, review gates, permission boundaries, and failure handling. The governance section formalizes this.
The velocity trap
As your speed rises, verification capacity becomes the binding constraint, not production. On high-stakes work, output can quietly outrun your ability to check it, and automation multiplies both the leverage and the cost of a single unverified error, because the output now flows straight into the world. Build the verification step into the workflow before you scale it, not after.
How the tools actually work
Objective: build an accurate mental model, so your instincts about what to feed the tool are correct instead of magical.
You do not need to know how the technology works inside. You need three plain facts, because each one tells you what to do differently.
One. It guesses the next words. It is not looking facts up in a database. That is why it can write beautifully and still get a number wrong. Use it to draft and shape. Do not trust it as a source of truth.
Two. It only knows what is in front of it. It sees this chat and any files you attach, and nothing else. If a detail matters, put it in the message. Do not assume it remembers last week.
Three. Its built-in knowledge has a cutoff date. For anything recent, tell it to search the web, or it may answer from stale memory.
You do not need the math. You need four practical facts, because each one changes how you should prompt.
1. It predicts, it does not look up
The model generates the next most plausible words from patterns in its training, not from a database of verified facts. It can be brilliant at structure and reasoning yet wrong about a specific number. Lean on it for drafting and thinking; do not trust it as a source of record. When a task needs real facts, ground it: attach the source, or turn on web search so the model reads current material instead of recalling it. That grounding pattern (retrieve, then generate) is what the industry calls retrieval-augmented generation.
2. Everything happens inside the context window
The model only knows what is in front of it: your message, the earlier turns in this chat, and attached files. That window is large now, often hundreds of thousands to a million-plus words, but still finite. If a fact matters, put it in the conversation, and do not assume memory across chats unless a memory or project feature carries it forward.
3. Context beats tricks
Current models respond best to plain, explicit instructions plus the reasoning behind them. Supplying the right information beats clever phrasing, and explaining why you want something beats dressing the request up in rituals.
4. Model choice is part of the prompt
Every platform offers a range from fast-and-cheap to slow-and-deep, plus a knowledge cutoff. Reaching for the right tier, and turning on web search when the answer must be current, matters as much as wording.
- Did I supply the context the tool could not already know?
- Is every fact, figure, name, and quote something I can confirm elsewhere?
- Is this recent enough that I should have turned on web search?
- Did I pick a model tier suited to the difficulty of this task?
The generator is probabilistic, which has direct operational consequences. Reliability is not uniform across a response: the model is strongest on high-frequency, well-structured patterns and weakest on specific low-frequency facts, which is exactly where fabrication concentrates. Aim verification there rather than spreading it evenly, and be most skeptical of precise figures, names, citations, and quotes.
Treat the context window as a working set you actively manage. Placement matters, since instructions and the material you most want attended to should sit where they are least likely to be diluted, and long stretches of irrelevant history degrade output (the "lost in the middle" effect). For long tasks, summarize and re-seed rather than letting the window sprawl, and lean on retrieval so only the relevant slice enters the window.
- Tokenization means the model sees sub-word chunks, not characters, which is the root of weak spelling, letter-counting, and exact character manipulation. Hand those to a code tool. It also explains why token counts, not word counts, govern context limits and API cost.
- Temperature and sampling control randomness. Most chat interfaces fix them, but through an API you lower temperature for deterministic extraction and raise it for ideation. Low temperature does not mean correct, only consistent.
- Knowledge cutoff makes built-in knowledge stale by definition. Ground anything time-sensitive with web search or supplied sources, and never rely on parametric memory for current facts.
- Reasoning models think before answering. They spend hidden intermediate computation on a problem, which raises accuracy on hard tasks at the cost of latency and price. The amount of that thinking is now an explicit control on several platforms.
- Model economics are a lever: reserve heavy reasoning tiers for tasks whose quality ceiling justifies the latency and cost, and push volume work to the lightest tier that clears the bar.
Core prompting technique
Objective: master the moves that carry most of the value, so you outperform people who only chase advanced tricks.
Three habits will fix most bad results. Do these and you are already ahead of most people.
- Be specific. Say who it is for, how long, and what form. "Write a 150-word friendly email to a customer explaining our new hours" beats "write an email."
- Give the background. Tell it the goal and anything it cannot know. Paste the details in.
- Let it say "I do not know." Add a line like "if you are not sure, say so instead of guessing." This alone cuts made-up answers.
If the first answer is not right, tell it what to change and ask again. The first try is a draft, not the finish. Treating it like a back-and-forth is normal and expected.
Six moves carry most of the value. Use them together and the first draft lands close. Each maker packages them into a named framework (Google's PTCF, Microsoft's GCES, and similar), but the moves are the same underneath.
1. Be explicit and direct
2. Give context and motivation
3. Be specific about constraints
Name the audience, length, format, and hard requirements. Specificity is where quality lives, and the makers agree the most productive prompts are precise, not long. Google's own guidance puts the sweet spot around twenty words of relevant context, well above the handful most people type.
4. Show an example
When a format is easier to show than describe, give one. Modern models study examples closely, so include only patterns you want repeated. Start with a single example (one-shot) and add more (few-shot) only if it still misses.
5. Give permission to be uncertain
Analyze this data and identify the trends. If the data is insufficient to draw a conclusion, say so directly rather than speculating.
6. Control the format by stating what to do
- Task. One clear instruction led by an action verb.
- Context. Audience, purpose, and why it matters.
- Constraints. Length, format, tone, hard requirements.
- Example. One sample of the style, only if needed.
- Safety valve. Permission to say "I do not know."
You already apply the six moves by reflex. The edge at this level is in the subtleties that trip up strong prompters.
- Positive framing dominates. Models steer toward what you name, not away from what you forbid. "Do not X" plants X; state the target behavior instead, and reserve negatives for genuine hard prohibitions.
- Examples are contagious. One-shot and few-shot examples transfer everything in them, including incidental format, length, and tone you did not intend. Curate examples as strictly as instructions, and prefer one clean example over several noisy ones.
- Specificity can over-constrain. On generative or exploratory tasks, tight specification narrows the search space and can suppress the better solution you did not think to request. Specify what matters and leave the rest open.
- Match register to output. The model mirrors your prompt. Terse prompt, terse output; markdown-heavy prompt, markdown-heavy output. Write the prompt in the voice and format you want back.
- Reasoning tiers want goals, fast tiers want steps. Give a reasoning model a clear objective, constraints, and a definition of done, and let it find the path. Give a fast model explicit, ordered instructions. The same prompt is not optimal for both.
- Motivation generalizes better than rules. A stated reason lets the model extend your intent to cases you did not enumerate; a bare rule gets applied narrowly and literally.
Advanced technique
Objective: add sophisticated moves for harder work, and know when they earn their keep.
When the basics are not enough, two simple additions solve most of it.
Ask it to think first. For anything with a few steps, add "think it through step by step before you answer." You get better reasoning.
Ask it to check its own work. Add a line like the one below and the finished piece comes back stronger.
Before you give me the final version, review your own draft
for anything weak or unclear and fix it. Show me only the
polished result.
Step-by-step reasoning
Ask the model to reason before it answers. On paid tiers, a built-in thinking or reasoning mode does this automatically and is usually the better choice. Otherwise, prompt it: "first work out X, then Y, then write the answer."
The self-critique loop
Before you respond, write an internal checklist for what a
world-class answer would include. Then draft, score your draft
against that checklist, and revise until it scores at the top
of every item. Show me only the final version.
Prompt chaining
Break a complex job into a sequence of focused prompts, each feeding the next. More reliable than one mega-prompt, because each step is easy to get right.
# Link 1 · produce Summarize this report: method, findings, implications. # Link 2 · review Review that summary for accuracy and gaps. Give graded feedback. # Link 3 · improve Rewrite the summary using this feedback: [paste feedback]
Decompose an overloaded prompt
A prompt trying to do five things at once produces weaker work than five focused prompts. Split it, and review between steps.
Let the model improve your prompt
Paste a weak prompt and ask the model to rewrite it for clarity before you run it. All four platforms support this, and several have a built-in prompt optimizer.
Stack techniques deliberately
The power is in combining moves in one pass: explicit instruction, private context, a shown format, a safety valve, and format control together.
Extract the quarterly metrics from this report. Context: this feeds an automated dashboard, so exact structure matters more than readability. Format: return only valid JSON in this shape: { "revenue": "value+units", "margin": "%", "growth": "%" } Safety valve: if a metric is not clearly stated, use null. Do not estimate. Control: begin with the opening brace and include no other text.
Structured output and prefilling
For machine-readable output, name the exact schema and tell the model to emit only that. Where the interface allows it, prefill the start of the response (an opening brace, a header row) to lock the format from the first token. Use null or an explicit "unknown" rather than inviting a guess.
Reasoning modes and effort
Prefer a built-in thinking or reasoning mode over manual chain-of-thought when one exists, and treat the reasoning-effort control as a dial: raise it for genuinely hard analysis, lower it for speed and cost on routine work. Manual step-by-step still earns its place on fast tiers without a thinking mode and when you need reasoning you can audit.
Meta-prompt and verify
Ask the model to write or improve your prompt before you run it; it is faster than hand-tuning. Then make the final link of any chain an adversarial check: "list every claim in the draft not supported by the source, so I can verify or cut it." For high-stakes work, run the same task through a second model, since different models fail on different inputs.
Retire the rituals
Heavy persona play, mandatory tag scaffolding, and manual reasoning where a thinking mode exists are mostly noise on current models. Reserve tags for genuinely complex multi-source prompts. Patterns like ReAct (reason-then-act loops) and tree-of-thought (branching exploration) matter more for building agents programmatically than for chat. The best prompt is the shortest one that reliably clears the bar.
Platform playbooks
Objective: apply the universal skills to the four tools you will actually use, and pick the right tool and the right model tier every time. For full per-platform specifications, see the deep dives in the next section.
The core skill works on all of them. Here is the plain-English version of what each one is good at.
- ChatGPT. The flexible all-rounder. A good default for drafting, questions, images, and general help.
- Claude. Strong at long writing, careful analysis, coding, and polished documents.
- Gemini. Lives inside Google. Great if your work is in Gmail, Docs, and Drive, and it handles very large documents.
- Copilot. Lives inside Microsoft 365. Great if your work is in Word, Excel, Outlook, and Teams.
Two tips that apply everywhere. Pick the tool that lives where your work already lives. And start with the fast, standard model; only switch to a slower "thinking" model when the answer is not good enough.
The core technique transfers between platforms. What differs is the native framing, the model tiers, the standing-setup features, and where each tool is grounded. The cards cover the same six topics for every tool.
- Prompt frame. Goal, constraints, and an output contract. Give reasoning models a goal; give fast models steps.
- Model tiers. Fast default, a reasoning tier, and a research-grade tier. A router often picks for you, so add signal if quality dips.
- Standing setup. Custom Instructions, Projects, Memory, and reusable Custom GPTs.
- Grounding. Web, file uploads, a code and data sandbox, image generation, and connectors.
- Best at. Versatility, images, voice, and the broadest ecosystem.
- Verify. It states wrong facts confidently and may route silently; confirm figures and quotes.
- Prompt frame. Be explicit, give context and motivation, and use one clean example.
- Model tiers. Fast, balanced, and flagship, with built-in extended thinking for hard reasoning.
- Standing setup. Projects, Styles and Skills, Artifacts for live outputs, and cross-chat Memory.
- Grounding. Web search with citations, plus connectors over the open Model Context Protocol.
- Best at. Coding, long-document analysis, and natural prose.
- Verify. Confirm every specific claim against a real source.
- Prompt frame. PTCF: Persona, Task, Context, Format. Always include a clear verb.
- Model tiers. Fast default and a flagship reasoning tier, with a top parallel-thinking mode on higher plans.
- Standing setup. Gems for reusable assistants, saved info, and file-backed knowledge.
- Grounding. Google Workspace with @-mentions, very large context, and native multimodal input.
- Best at. The Google ecosystem, long context, and image and video work.
- Verify. Grounding helps, but still verify what carries your name.
- Prompt frame. GCES: Goal, Context, Expectations, Source. Name the files it should ground on.
- Model tiers. A choice of models, including options from more than one maker, plus fast and deeper modes.
- Standing setup. Copilot Notebooks, a shared Prompt Gallery, Agent Builder, and custom agents.
- Grounding. Microsoft 365 through Microsoft Graph, with sensitivity labels and connectors.
- Best at. Work inside Microsoft 365 and enterprise governance.
- Verify. Microsoft's own rule is trust but verify; review every output.
Which tool, when
| Your situation | Reach for |
|---|---|
| Your data lives in Google Workspace | Gemini |
| Your data lives in Microsoft 365 | Copilot |
| Coding, long documents, careful writing | Claude |
| General versatility, images, voice | ChatGPT |
| High-stakes work | A primary tool plus a different one to verify |
Model selection, in plain terms
| Task type | Reach for | Why |
|---|---|---|
| Quick reformat, summary, rewrite | Fast tier | Cheap and quick; the task is easy |
| Analysis, strategy, multi-step logic | Reasoning tier | Depth and reliability over speed |
| High-stakes finished deliverable | Top tier + self-critique | Quality ceiling justifies the cost |
| High-volume, cost-sensitive | Lightest capable tier | Do not overpay for simple work |
Treat model choice as calibration, not loyalty. Reasoning tiers behave like a senior colleague: give them a goal and let them work out the path. Fast tiers behave like a sharp junior: they need explicit, specific instruction. Match the tool and tier to the task and your prompt register to the tier.
- Control effort deliberately. The durable knob across platforms is how hard the model thinks. Dial it up for genuinely hard reasoning and down for latency and cost on routine work, rather than defaulting to the heaviest tier out of habit.
- Route with intent. Where a platform auto-routes simple prompts to a lighter model, quality can dip on a task you know is hard. Add signal or select the model by hand.
- Play to native ground. The ecosystem-embedded tools are strongest against data already inside their world, so the marginal value of switching is highest when your source of truth lives in Google Workspace or Microsoft 365. The portable tools win on general, cross-context work.
- Frameworks converge. PTCF, GCES, and the goal-plus-contract style are one discipline under different names. The real divergence between platforms is grounding and governance, not the acronym.
- Run cross-tool workflows. Draft in the strongest writer, ground and distribute in the ecosystem tool, and verify in a different model. Some shells even let you select models from more than one maker in one place, which matters for both capability and governance.
- Verification is constant. No amount of grounding removes it. Grounding only changes where the highest-risk fabrication is likely to sit.
Platform deep dives
Objective: a full, side-by-side reference profile of each platform. Shown at every reading level.
verify before use · current as of mid-2026
Model names, context sizes, pricing, and availability below reflect research current to mid-2026 and change every few months. Some figures come from secondary coverage rather than the makers' own pages, and one Gemini detail is disputed (noted inline). Treat every specific name and price here as a starting point and confirm it on the maker's own page before you rely on it.
the versatile all-rounder · the most widely used assistant, reportedly around a billion monthly users in 2026
| Tier | Model (mid-2026) | Best for | Context |
|---|---|---|---|
| Flagship | GPT-5.6 Sol | Complex professional work | ~1M tokens |
| Balanced | GPT-5.6 Terra | Everyday tasks, cheaper | ~1M tokens |
| Fast | GPT-5.6 Luna | High-volume, low cost | ~1M tokens |
| App: fast | GPT-5.x Instant | Free default in the app | Large |
| App: reasoning | GPT-5.x Thinking | Harder analysis (paid) | Large |
A real-time router often picks the model for you, pairing a fast model with a deeper one as needed. Reasoning effort is an explicit control on the reasoning tiers. Knowledge cutoff is in early 2026. The app model picker lags the developer platform, so names differ between them.
OpenAI distinguishes reasoning models ("a senior co-worker: give a goal and trust them with the details") from classic models ("a junior co-worker: give precise instructions"). For reasoning tiers, supply a clear goal, strong constraints, and a definition of done, and avoid over-specifying intermediate steps. Treat each new model as a fresh baseline to tune for, not a drop-in replacement.
- Standing setup. Custom Instructions (global tone and role), Projects (scoped workspaces with their own files and project-only memory), Memory (an editable saved list plus implicit chat-history reference), and Custom GPTs.
- Grounding. Web browsing, file uploads, a Python data-analysis sandbox, image generation, and connectors.
- Automation. Scheduled Tasks run recurring or one-off prompts and web-monitoring jobs, then notify you (roughly hourly floor, around ten active). Agent Mode runs bounded, supervised multi-step tasks in a browser.
Free; a low-cost Go tier; Plus (mid-tier monthly); Pro (premium, several times the usage plus the research-grade model); Business and Team (per-seat); and Enterprise (sales-led, no training on customer data). Verify current prices.
- Strengths: versatility, image and voice, the broadest plugin and tool ecosystem, strong autonomous task execution.
- Weaknesses: enterprise data-integration depth trails Copilot; conversation organization is thin; silent routing can surprise you.
the craftsman · strongest on coding, long-document work, and natural writing
| Tier | Model (mid-2026) | Best for | Context |
|---|---|---|---|
| Top | Fable 5 (Mythos class) | Long-running agents | 1M tokens |
| Flagship | Opus 5 | Agentic coding, enterprise (recommended default) | 1M tokens |
| Balanced | Sonnet 5 | Speed and intelligence (a common default) | 1M tokens |
| Fast | Haiku (current) | Fast, near-frontier | 200K tokens |
Most tiers support extended or adaptive thinking, and reasoning effort defaults high on the flagship tiers. A restricted, invitation-only sibling of the top model exists for defensive security use. Knowledge cutoffs vary by model, in the first half of 2026.
Anthropic's published best practices: be explicit and clear, provide context and motivation (explain the why behind a rule), be specific, use one clean example before adding more, and give Claude permission to express uncertainty. Advanced moves include prefilling the response (start it with an opening brace to force JSON) and chain-of-thought with thinking tags. It advises retiring heavy tag scaffolding and elaborate personas on modern models.
- Standing setup. Projects (which switch to retrieval as files grow, raising effective capacity), account Instructions, Styles moving into Skills (reusable instruction bundles that also work in other tools), Artifacts (live, editable outputs with persistent storage), and cross-chat Memory on all plans.
- Grounding. Web search with inline citations, Google Workspace, and connectors over the Model Context Protocol, the open standard Anthropic introduced and later donated to the Linux Foundation.
- Automation. Cowork packages autonomous file-and-document work in a visual app; Cowork Scheduled Tasks run a saved prompt on a cadence in the cloud; Code Routines trigger on schedule, webhook, or repository event; sub-agents and agent teams split work across scoped sessions.
Free; Pro; a higher Max tier; Team; and Enterprise. Verify current prices and limits.
- Strengths: coding (especially large multi-file work), long-document accuracy, prose quality, agentic file manipulation.
- Weaknesses: narrower consumer ecosystem; no native image or video generation; some features depend on the desktop app.
the ecosystem native · huge context, native multimodality, and deep Google Workspace reach
| Tier | Model (consumer, mid-2026) | Best for | Context |
|---|---|---|---|
| Flagship | Gemini 3.1 Pro | Advanced reasoning | 1M (Pro/Ultra) |
| Fast / free | Gemini 3.x Flash | Everyday, free default | Smaller on free |
| Top mode | Deep Think (top plan) | Hardest reasoning | top plan |
disputed detail
Some secondary sources report a consumer "Gemini 3.5 Pro" with a two-million-token window announced mid-2026, but Google's own consumer pages name Gemini 3.1 Pro with a one-million-token window as the flagship. Treat the larger figure as unverified until Google confirms it.
The million-token window handles roughly 1,500 pages or tens of thousands of lines of code at once, though the free tier caps context well below that.
Google's PTCF framework: Persona, Task, Context, Format. Its own guidance notes the most productive prompts average around twenty words of relevant context and always include a clear verb, and it encourages iterating, rephrasing, and breaking complex requests into separate prompts.
- Standing setup. Gems (reusable custom assistants with saved instructions and a knowledge section; premade Gems include a brainstormer, coding partner, and writing editor), saved info, Canvas, and Deep Research.
- Grounding. Native Google Workspace access with @-mentions to pull in Gmail, Drive, Docs, and Calendar, plus URL, video, and map context and multimodal input.
- Automation. Scheduled Actions run recurring prompts (around ten active, paid), best for daily summaries since results are prepared shortly before delivery. Workspace Studio is a no-code flow builder that can run a private Gem as a step, and a browser agent handles parallel web tasks on the top plan.
Free; a low-cost AI Plus tier; AI Pro (mid monthly, adds the largest context and Workspace features); and AI Ultra (premium, adds Deep Think, video generation, and the browser agent). Verify current prices.
- Strengths: anyone in Google Workspace, huge-context and long-document work, native image and video, bundled storage, enormous reach through Search and Android.
- Weaknesses: historically trails on writing polish; confusing consumer model naming; some capabilities gated to the top plan.
the enterprise layer · embedded in Microsoft 365, multi-model, governance-first
| Role | Model (mid-2026) | Notes |
|---|---|---|
| Preferred | OpenAI flagship (GPT-5.6) | Default across Office apps |
| Selectable | Anthropic Claude | Admin-enabled; off by default in EU/UK; runs on Anthropic systems |
| Fast | OpenAI fast tier | Low-latency work |
| In Studio | Choice per prompt | OpenAI, Claude, or open models |
"Preferred" is a distribution choice, not a capability verdict; where the picker is available you can select directly, and many teams prefer Claude for heavy analysis. Model routing logic is not published.
Microsoft's GCES framework: Goal (the only required part), Context (why and who), Expectations (format, length, tone, audience, primed precisely), and Source (which files, sites, or emails to ground on, including or excluding specific URLs). The added habit is to iterate.
- Standing setup. Copilot Notebooks (project workspaces that pull chats, files, meetings, and emails together and can generate Office documents), a Prompt Gallery with admin-published org prompts, Agent Builder, and custom agents.
- Grounding. Deep Microsoft 365 access through Microsoft Graph (SharePoint, Teams, Outlook, OneDrive), org-data grounding, federated connectors, MCP servers, and hundreds of workflow connectors, all inheriting existing identity, sensitivity labels, and governance.
- Automation. Copilot Studio builds low-code agents from knowledge, tools, and conversation paths; agent flows add deterministic, repeatable steps (the precision layer to the agent's reasoning layer); computer-using agents drive app interfaces where there is no API; a work assistant handles long-running tasks; scheduled prompts run on a cadence; enterprise governance runs through an agent-management layer with evaluation and usage-based billing.
A consumer premium plan (monthly or annual); business plans with Copilot added per seat; and an enterprise add-on per user, now paired with usage-based credits for agent and Cowork activity. The older standalone consumer Copilot Pro is being retired for new buyers. Verify current prices.
- Strengths: organizations on Microsoft 365, enterprise security and compliance, frictionless in-app help across Office, and genuine model choice.
- Weaknesses: narrower as a general-purpose standalone tool; scattered product surface and complex licensing; opaque model routing.
Build your prompt library
Objective: stop reinventing prompts, and turn the wins into a system that compounds. Ready-to-use templates live in the next section.
When a prompt gives you a great result, do not lose it. Copy it into a notes document you can reuse. Good prompts are tools you keep, not things you retype.
Getting a prompt right is simple: try it, see what is off, change one thing, try again. When it reliably works, save it. Next time is faster.
The difference between a casual user and an operator is repeatability. Save what works, refine it, and reuse it until it is reliable infrastructure. A reliable prompt is also the raw material for the automation later in this manual.
The iteration loop
- Draft. Write your best first prompt using the everyday pattern from Module 02.
- Test. Run it. Read the output as a skeptic against your actual need.
- Diagnose. Name the specific gap: too generic, wrong format, off-topic, invented facts.
- Adjust one thing. Change one variable so you know what worked.
- Save the winner. When it reliably delivers, file it. That prompt is now an asset.
Judge a prompt on four questions
Does it match the requirement? Did you get there in one pass or many? Is the format stable when you run it again? Does it resist the vagueness failure? A prompt that clears all four is worth keeping, and is ready to automate.
- Write custom instructions, preferences, a Gem, or a Prompt Gallery entry once, so tone and role apply everywhere.
- Keep a running document of your best prompts, organized by job.
- Group recurring work into Projects with the right files attached.
- For anything weekly, promote the instruction from the prompt into the standing setup.
This is context engineering. Move stable instructions out of individual prompts and into the platform's persistence layer, custom instructions, Projects, reusable skill or instruction files, Gems, or an org Prompt Gallery, so the prompt shrinks to the task-specific delta and your setup does the heavy lifting.
- Version and re-baseline. Keep a dated changelog. When a new model generation ships, re-test rather than assuming old prompts transfer; the makers themselves stress that a new model is a fresh baseline to tune for, not a drop-in.
- Change one variable at a time so every result is attributable. Batteries of simultaneous edits teach you nothing.
- Keep a small eval set. Hold a handful of representative inputs with known-good outputs, define success criteria first, and re-run a changed prompt against them to catch regressions before production.
- Judge on four axes: match to requirement, passes needed, format stability on re-run, and resistance to vagueness. Clearing all four means automation-ready.
- Pin production work to a specific model version where the platform allows it, so a silent model update does not change your outputs underneath you.
Watch your own velocity
A mature library makes you fast enough that verification, not production, becomes the bottleneck, and that gap widens the moment you automate. Build the check into the workflow itself so speed never quietly outpaces accuracy.
Prompt and template library
Objective: copy-ready prompts organized by job. Fill in the highlighted parts. Shown at every reading level.
Everyday
Summarize the text below for [audience] so they can [decision or action]. Keep it under [N] words, lead with the single most important point, and flag anything uncertain. [paste text]
Rewrite the text below to be [warmer / more concise / more formal] for [audience]. Keep the meaning and any specific facts unchanged. Do not add claims that were not there. [paste text]
Explain [topic] to someone who is new to it. Use plain
language and one everyday analogy. Then add one sentence on the
most common misunderstanding.
Analysis
From the document below, extract [fields] as [a markdown table / valid JSON] with exactly these columns: [list]. If a value is not clearly stated, use "unknown" rather than guessing. Output only the result. [paste document]
Compare [options] for [goal]. Give a short table scoring each on [criteria], then a one-paragraph recommendation with its main risk. Note where you are unsure.
Writing
Here are two things I wrote, so you can match my voice: sentence length, rhythm, how formal. [paste 2 samples] Now write [what] about [topic], matching that voice. Give me the draft, then three alternative opening lines.
First give me a tight outline for [document] aimed at [audience], with one line per section. Wait for my okay before writing the full draft.
Reasoning and quality
Before you respond, write a checklist for what a world-class answer to this would include. Draft, score your draft against it, and revise until it tops every item. Show only the final.
Help me decide [decision]. List the options, the two or
three factors that actually matter, and how each option scores.
End with what you would choose and the strongest case against it.
Chaining and verification
Review the draft above against the source material. List every claim, number, or quote that the source does not clearly support, so I can verify or cut it. Do not rewrite anything yet.
Summarize what these sources agree on, where they conflict, and
what is still unknown. Attribute each point to its source, and
do not merge a claim from one source into another.
[paste sources]
Automation and meta
Every [day/time], summarize the last [period] from [source]: what changed, what needs my attention, and the top three items ranked. Under [N] words. Flag anything uncertain instead of guessing.
Here is a prompt I am using. Rewrite it to be clearer and more
specific, ask me for any missing context, and explain what you
changed and why.
[paste prompt]
Automation, tasks, and workflows
Objective: move from invoking AI by hand to designing systems that run on their own. The safety rules live in the governance section.
You can put a prompt on a schedule so the tool does it without you. The safest place to start is a simple daily summary, something that only reads and reports, so the worst case is a weak summary rather than a wrong action.
There are roughly four steps up in power: you do it by hand, you save a reusable prompt, you schedule a prompt to run on its own, and finally you let the tool act across your apps. Climb one step at a time, and always review what it produces before you trust it.
A "summarize my unread email every morning" task is a great first automation. Review each result until you trust it.
The real shift is from asking AI questions to designing AI coworkers. All four platforms now let a prompt run on its own or act across your apps. Climb this ladder one rung at a time.
Manual chat
You prompt, read, and act. Correct for one-off and novel work.
Structured workflow
Saved prompts, projects, standing instructions, and chains you run by hand.
Scheduled tasks
A proven prompt on a clock. It runs and delivers a result you review. It mostly tells you things.
Agentic execution
The tool acts across your apps, multi-step, with your sign-off. It does the work.
What each platform gives you
- Reusable assistant. Custom GPTs and Projects.
- Scheduling. Scheduled Tasks run prompts on a clock and notify you.
- Agent execution. An agent mode acts across web, files, and apps.
- Reach. The web and your uploads.
- Reusable assistant. Projects and Skills.
- Scheduling. Scheduled tasks run a saved prompt on a cadence, in the cloud.
- Agent execution. A work assistant plus sub-agents and code routines; triggers on schedule, webhook, or repo event.
- Reach. Connectors over the open Model Context Protocol.
- Reusable assistant. Gems.
- Scheduling. Scheduled Actions turn a prompt or chat into a recurring task.
- Agent execution. A no-code flow builder triggers a Gem on an event, plus a browser agent.
- Reach. Gmail, Drive, Docs, and Calendar.
- Reusable assistant. Agent Builder and custom agents in Copilot Studio.
- Scheduling. Scheduled prompts and deterministic agent flows.
- Agent execution. Studio agents, a work assistant, and agents that drive the screen where there is no API.
- Reach. Microsoft 365 through Microsoft Graph.
What to use when
| You want to | ChatGPT | Claude | Gemini | Copilot |
|---|---|---|---|---|
| Reuse a fixed assistant | Custom GPT | Project or Skill | Gem | Studio agent |
| Run a prompt every morning | Scheduled Task | Scheduled Task | Scheduled Action | Scheduled prompt / flow |
| Work across your apps | Agent mode | Cowork agent / routine | Studio flow | Studio agent / Cowork |
| Keep grouped context | Projects | Projects | Gem with files | Copilot Notebook |
Two practical notes: scheduled tasks mostly report rather than act, and they prepare their answer shortly before delivery, so they suit daily summaries more than fast-moving data. Cloud-run tasks fire on their own; tasks tied to your desktop app only run when your machine is awake.
At the agent tiers, prompting becomes system design. The controlling variables are autonomy, permission scope, and the human gate, and you tune them against the cost of a wrong action, not the difficulty of the task.
- Find the repeat. Anything you do the same way more than weekly is a candidate.
- Prove it by hand. Get the prompt reliable at Level 1 before automating.
- Pick the lowest level that works. Do not build an agent when a scheduled prompt will do.
- Separate reasoning from execution. Let the agent decide, and use deterministic flows to carry out the consequential steps.
- Set the review gate. Decide exactly what a human approves before anything is sent, posted, or paid.
- Name the failure mode. Ask what happens on bad input, and build the check that catches it.
- Start it, then watch it. Review the first several runs closely before trusting it unattended.
Design patterns worth internalizing: the reasoning layer decides and the deterministic layer executes; sub-agents isolate context and permissions so one runaway step cannot touch everything; and every scheduled or agentic run should leave a reviewable trail. The governance section formalizes the permission and review model.
Governance, safety, and verification
Objective: the rules that keep AI use safe, accurate, and defensible, especially once you automate. Shown at every reading level.
Confidence is not accuracy. Fabrication concentrates on specific, low-frequency facts, precise figures, names, citations, dates, and quotes, so aim your scrutiny there. Practical habits:
- Ground, then trust. Turn on web search or attach the source for anything factual or recent, and check that cited sources exist and actually say what is claimed. Models fabricate plausible citations and quotes.
- Cross-check numbers with a calculator or the model's code tool, never by eye.
- Use a second model for high-stakes review. Different models fail on different inputs, so one often catches the other's error.
- Require uncertainty. Give explicit permission to say "I do not know," and ask the model to flag assumptions and low-confidence points.
- Know what you are pasting. Do not put secrets, personal data, or regulated information into a consumer tool without checking its data and training terms. Enterprise tiers typically do not train on your content and inherit your organization's controls; consumer tiers vary.
- Respect classification. In enterprise tools, sensitivity labels and access permissions carry through to what the assistant can see and produce. Do not engineer around them.
- Watch cross-provider flows. When one vendor's product runs another maker's model, your data may be processed on the second maker's systems under separate terms. Some organizations disable such options by default and enable them deliberately. Treat model choice as a data-governance decision, not just a quality one.
Agents raise the stakes because they act, not just report. The risk jumps at the top rung of the automation ladder, so the controls tighten there.
- Least privilege. An agent and its tools run with the same access as the session. Grant the minimum scope the task needs, and audit every connector and permission you attach.
- Human gates. Require explicit sign-off before any action that sends, deletes, pays, publishes, or changes a system of record. Automate the reasoning, not the irreversible step.
- Reasoning and execution split. Let the model decide and a deterministic flow carry out consequential actions, so behavior is repeatable and testable.
- Reviewable trail. Every scheduled or agentic run should log what it did. If you cannot review it after the fact, you cannot trust it before.
- Test before you trust. Prove each step on sample inputs, then watch the first live runs closely. Common failure modes are silent wrong assumptions, over-reach beyond the intended scope, and modifying things that were out of bounds.
For regulated or high-consequence work, prefer enterprise tiers with the compliance posture your context requires, keep a human accountable for every AI-assisted output, and remember that "the model said so" is never a defense. The person who ships the work owns the work.
- Every fact, figure, name, and quote is verified against a real source.
- No secret, personal, or regulated data went into a tool that should not have it.
- Any agent acted within least-privilege scope, with consequential steps gated by a human.
- There is a reviewable record of what an automated run did.
- A named human, not the model, is accountable for the result.
Quick reference
Objective: the tear-off card. Keep this open while you work.
- Be specific: who it is for, how long, what form.
- Give the background it cannot know.
- Let it say "I do not know" so it stops guessing.
- The first answer is a draft. Tell it what to fix and ask again.
- Check every fact before you use it.
Technique selector
| If you need | Use |
|---|---|
| A specific output format | Show one example, or state the format and say "begin with it" |
| Step-by-step reasoning | Built-in thinking mode, or ask it to reason first |
| A polished finished piece | The self-critique loop |
| A complex multi-stage job | Prompt chaining with a verification link |
| Fewer invented facts | Permission to say "I do not know," then verify |
| Current information | Turn on web search; do not trust built-in memory |
| A task done daily on its own | A scheduled task, once the prompt is proven |
Troubleshooting
| Symptom | Fix |
|---|---|
| Output too generic | Add specifics and examples; ask it to go beyond the basics |
| Missed the point | State your real goal and why you are asking |
| Inconsistent format | Add an example, or specify the exact structure |
| Unreliable on a hard task | Break it into a chain of smaller prompts |
| Made up information | Give permission to be uncertain, then verify anyway |
| Answer feels out of date | Turn on web search or supply the current source |
- I direct the work; I do not just ask questions.
- I supply context the tool cannot know, and move stable context into standing setup.
- I calibrate the tool and tier to the task, and my prompt register to the tier.
- I automate only what I have proven by hand, at the lowest autonomy that works.
- I verify every fact before it carries my name, and I gate agents on a human sign-off.
- I version what works and re-test it when a new model ships.
Advanced defaults: positive framing over prohibitions, one clean example over many, goals for reasoning tiers and steps for fast ones, effort dialed to the task, thinking modes over manual reasoning, and verification concentrated where low-frequency facts live.
Glossary
Objective: plain-language definitions of the terms in this manual. Shown at every reading level.
on staying current
The teaching in this manual rests on durable concepts: tiers, reasoning effort, standing setup, grounding, the automation ladder, and verification. Those outlast any release. The specific model names, context sizes, and prices in the deep dives were current to mid-2026 and carry verify callouts because they change often. For today's exact figures, go to the source: the prompting and product documentation published by Anthropic, OpenAI, Google, and Microsoft. Re-check when a maker ships a new flagship generation, changes the default model in its app, restructures pricing, or brings a new agent capability to general availability.
Field Reference · Rev. 2026.7 · comprehensive edition