How to Use ChatGPT at Work: A Complete Professional Guide

Professional use of ChatGPT is not determined by one perfect prompt. The result depends on a set of separate decisions: where the work runs, which context is available, which instructions apply, which model and reasoning effort are selected, which tools may be used, what actions are permitted, and how the output is checked.

This guide provides a practical operating method for Chat, ChatGPT Work, and Codex. It explains how to configure account-level preferences, organize ongoing work in Projects, add the right files and sources, select model and reasoning controls where they are available, use web search and connected tools deliberately, and verify the result before professional use.

The guide follows the current OpenAI Learn documentation reviewed on August 18, 2026. OpenAI can change model names, interface labels, availability, and workspace controls. Treat the current interface and current official documentation as the source of truth when a control is missing or named differently.

1. Define the outcome. State what ChatGPT should produce, who will use it, and what makes it complete.
2. Choose the work surface. Use Chat for a question or back-and-forth, ChatGPT Work for a larger task with a reviewable result, and Codex for software development and developer tooling.
3. Choose the context boundary. Decide whether the task needs only the current message, one-off attachments, a Project, Library files, memories, web sources, or connected services.
4. Place instructions in the correct layer. Put account-wide preferences in Personalization, ongoing-work rules in Project Instructions, and the immediate deliverable and constraints in the current prompt.
5. Select the model and reasoning effort where the surface exposes that control. Start with the default and increase reasoning only when the task requires more planning, analysis, or checking.
6. Authorize only the required tools and actions. Distinguish permission to inspect, permission to draft, and permission to execute.
7. Review the result against the original sources and acceptance criteria. A polished answer or file is still a draft until the important claims, numbers, sections, and actions have been checked.

A weak result should be diagnosed by layer. Do not respond automatically by writing a longer prompt. First check whether the task was routed to the wrong surface, given the wrong context, constrained by an old instruction or memory, assigned insufficient reasoning, or executed without the required source or tool.

OpenAI currently separates three primary ways of working. The correct choice depends on the required result, not only on the topic.

Selection rule

Use the narrowest surface that can produce the required result. A programming explanation can stay in Chat. A change that requires repository inspection and tests belongs in Codex. A short summary can stay in Chat. A presentation assembled from several files belongs in Work.

Local or cloud work

In the desktop app, Work may expose local and cloud execution. Use local work when the task needs files or applications on the computer. Use cloud work when the task should continue without depending on the local computer being awake, subject to the options and workspace controls available in the account.

Check: before continuing, name the primary output. If it is only an answer, Chat may be sufficient. If it is a substantial reviewable deliverable, use Work. If completion requires a codebase or developer environment, use Codex.

Personalization supplies reusable account-level preferences and context. It should reduce repetition across chats, but it should not become the authoritative location for a client file, project rulebook, factual record, or task-specific requirement.

Personality, tone, and style

OpenAI currently documents Friendly, Pragmatic, and None as the default Personality options in Settings → Personalization. Personality changes how ChatGPT communicates; it does not change the model’s capabilities.

Use the layers as follows:

• Personality — choose the broad communication default.
• Custom Instructions — state durable preferences that should apply across chats, such as language, evidence presentation, or a default writing convention.
• Current prompt — define the tone, audience, length, and style required for the current deliverable.

Do not assume that a broad personality can satisfy a specific writing brief. “Pragmatic” does not replace an instruction such as “write a neutral one-page board memo, put the decision first, and preserve the approved terminology.”

Custom Instructions

Use Custom Instructions for guidance that is useful across unrelated conversations. Appropriate examples include:

• the default response language;
• a preference for concise or detailed explanations;
• a requirement to distinguish sourced facts from assumptions;
• a preferred citation or date format;
• stable accessibility or formatting preferences.

Do not put project-specific terminology, client facts, passwords, access tokens, temporary deadlines, or a long workflow specification in account-level Custom Instructions. Project-specific guidance belongs in the Project; task-specific guidance belongs in the current prompt.

Memory

Memories let ChatGPT carry useful context from earlier work into future chats. Treat Memory as a recall layer for stable preferences, recurring working context, and information that would otherwise need to be repeated. Do not treat it as the only source for a rule that must always apply or a fact that must be reproduced exactly.

Use Memory for information such as a stable language preference, a recurring professional role, or a durable working convention. Use an attached file, Project source, connected system, or current verified source for exact records, policies, numbers, or client data.

Memory Summary

Documentation status: NOT VERIFIED as a separate mechanism. The current OpenAI Learn page for Memories reviewed for this guide documents Memory and its management through Personalization, but it does not define Memory Summary as a separate mechanism or document one universal set of controls for that label.

If the label appears in the account, use it as an interface for reviewing the context shown there and correct or remove information through the controls that the account actually exposes. Do not treat the summary as an authoritative source for the current task, and do not infer undocumented behavior from the label.

Computer History

Computer History is a separate, opt-in macOS desktop feature that can turn activity across allowed apps and websites into memories and a timeline. Enable it only when that additional context is required. Review the included apps and websites, and use the available inspection, exclusion, pause, and deletion controls before relying on it for professional work.

Check: every item in Personalization should be appropriate across many conversations. Move anything specific to one project, source set, client, or deliverable into the narrower layer.

The visible prompt is only one input. ChatGPT can also receive context from the current conversation, attached files, Project sources and instructions, memories, Library files selected for the task, installed plugins, web search, browser pages, and other tools available to the active surface.

Separate instructions from evidence

An instruction tells ChatGPT what to do. A source supplies information. A tool provides a capability. An approval authorizes an action. Do not collapse these categories.

For example, a Project Instruction can require “use only approved policy files,” but the instruction does not supply those policy files. The files must also be present in Project Sources or attached to the chat. Likewise, connecting a service makes a supported tool available; it does not tell ChatGPT which record is authoritative or whether it may modify anything.

Control stale context

When current information conflicts with older context, state the current fact and identify the source that should control the task. If a chat has accumulated unrelated branches, start a separate chat for the new outcome. If a memory is wrong, correct or remove it instead of repeatedly counteracting it in prompts.

Create a Project when work will continue over time, produce more than one output, or depend on the same files, instructions, and connected sources. Use a standalone chat when the task is self-contained and does not need shared Project context.

What to add to a Project

• Project Instructions: purpose, audience, terminology, source boundary, recurring output conventions, approval rules, and verification requirements.
• Source files: approved briefs, policies, datasets, templates, examples, decision records, glossaries, and reference material that future chats may need.
• Connected sources: supported external locations that contain current Project information, when the matching plugin and permissions are available.
• Separate chats: one chat for each distinct outcome, such as research, drafting, review, or implementation.

Do not add unrelated clients, obsolete drafts, unverified generated outputs, or every available document “just in case.” More context is not automatically better context. A Project should contain the smallest coherent source set that supports its recurring work.

Project setup procedure

1. Create or select the Project for one coherent body of work.
2. Write Project Instructions that describe persistent behavior, not the immediate task.
3. Add only the files and connected sources that should be reusable across Project chats.
4. Start a new chat inside the Project for each distinct deliverable.
5. In the current prompt, name the exact sources that should govern this task and define the output and acceptance criteria.
6. Verify generated work before preserving it as reusable Project context.

Project Instructions template

Purpose:
[What recurring body of work does this Project support?]

Audience:
[Who uses the outputs?]

Source boundary:
[Which Project files or connected sources are authoritative?]
[What may not be used without explicit approval?]

Persistent rules:
[Terminology, formatting, review, privacy, and approval requirements.]

Missing information:
[What should ChatGPT do when required evidence is absent or conflicting?]

Verification:
[What must be checked before an output is treated as reusable?]

Keep the immediate deliverable out of this reusable block. Put “create the Q3 board presentation from files A and B” in the current chat, not in the persistent Project Instructions.

The current official term is reasoning effort, not “intelligence effort.” The current OpenAI model guidance applies to ChatGPT Work and Codex. In those surfaces, the model and reasoning control appears beneath the composer where available. Do not assume that the same control, labels, or models are exposed in every Chat surface, plan, or managed workspace.

Start with the Power control

OpenAI documents the default Power setting as GPT-5.6 Sol with medium reasoning. Move toward Smarter when the task needs deeper reasoning, or toward Faster when the task is clear and speed or usage matters. Open Advanced when you need a specific model, reasoning effort, or speed.

Choose among Sol, Terra, and Luna

Choose reasoning effort

• Light — quick, well-scoped tasks.
• Medium — balanced speed and depth for work that needs planning.
• High and Extra High — difficult work with several steps, sources, constraints, or trade-offs.
• Max — gives the selected model more time for one of the hardest single tasks.
• Ultra — uses subagents for complex work that can be divided into meaningful parallel parts.

Use the lowest effort that reliably produces the required result. Higher effort takes longer and uses more tokens. It cannot recover missing evidence, correct an unclear goal, or decide which source is authoritative unless those inputs are supplied.

Practical selection examples

• Extract defined fields from many consistent records → Luna with Light or Medium.
• Prepare a standard project status report from supplied sources → Terra with Medium.
• Reconcile conflicting requirements and produce a decision memo → Sol with High or Extra High.
• Investigate one exceptionally difficult problem where depth matters more than speed → Sol with Max, where available.
• Produce a large deliverable whose research, analysis, and validation can be separated → Ultra, where available and where parallel work is actually useful.

Check: if the result is weak, determine whether the problem is reasoning depth or missing task definition. Do not increase effort to compensate for absent sources, contradictory instructions, or an undefined deliverable.

A capability should follow from a concrete requirement. Do not add web access, connected services, browser control, or desktop control to a task that can be completed from the supplied context.

Web search

Ask for web search when the answer depends on current information or external verification. State the claim to verify, the preferred source type, the relevant date, and the required evidence display. Treat all web results as untrusted input.

Verify the current product behavior using official vendor documentation. State the documentation date, cite each material claim, and separate documented behavior from interface-dependent availability.

Research in ChatGPT Work

Use Work when the task requires a larger research outcome rather than a quick answer. Define the research question, allowed sources, excluded sources, date boundary, expected report structure, and unresolved questions. Work can combine web search, browsing, files, and plugins when they are available.

Terminology note: the current OpenAI Learn documentation set reviewed on August 18, 2026 documents research through ChatGPT Work, web search, browser, files, and plugins. It does not provide a separate current ChatGPT guide for a control named Deep research. This version therefore does not present that label as a stable standalone workflow. If the label appears in an account, verify its current behavior and availability in the interface and official documentation before relying on it.

Plugins and connected services

Plugins can add reusable instructions, connectors, MCP tools, and other supported capabilities. Install only what the task needs. A connected service still uses its own authentication and access controls. Connecting it does not approve every action.

Skills for repeatable workflows

Use a Skill when good results depend on a repeatable process, supporting resources, templates, or checks. A Skill packages task-specific guidance; a Project keeps the context for one ongoing body of work; and a plugin is an installable bundle that can include Skills, connectors, or both. These mechanisms solve different problems.

Keep each Skill focused on one recognizable workflow. Test it with representative successful, incomplete, and conflicting inputs before relying on it across a team.

Browser and Computer Use

Use Browser for website research or interaction. Use Computer Use when a task depends on a graphical desktop interface and a structured integration is insufficient. Prefer a dedicated plugin or structured source when one exists; it is generally easier to scope and verify than visual interaction.

Voice, Visualizations, and Sites

Use ChatGPT Voice for live spoken coordination in supported Chat, Work, or Codex chats. Voice dictation is different: it converts speech into prompt text before sending. When Voice uses screen context or directs another task, the relevant permissions still apply.

Use a Visualization when a chart, map, diagram, calculator, simulation, or adjustable input materially improves understanding. Use Sites when the required result is a hosted website or application with a shareable deployment. OpenAI currently states that every Sites deployment URL is a production deployment; save a version without deploying when review must happen before publication.

OpenAI’s current prompting guidance does not require a rigid formula. For important work, include the parts that materially change the result: the goal, useful context, required output, and boundaries.

Goal

Describe the result, not only the topic.

Prepare a one-page decision memo comparing the three proposals for the procurement committee.

Context

Name the files, Project sources, connected locations, dates, and background that should affect the result. Explain the role of each source when it is not obvious.

Use the approved requirements file as the source of truth. Use the three vendor proposals only for vendor claims. Use current official documentation to verify product capabilities.

Output

Define the format, audience, length, order, and level of detail that make the work usable.

Return: 1) recommendation, 2) decision table, 3) unsupported or conflicting claims, 4) open questions, and 5) sources. Keep the main memo to one page.

Boundaries

State what must remain unchanged, what must not be inferred, which actions require approval, and what ChatGPT should do when information is missing.

Do not change approved budget figures. Do not contact vendors. If a required criterion is not supported, mark it as not verified instead of assigning a score.

Reusable task template

Outcome:
[What should ChatGPT produce, and who will use it?]

Context and sources:
[Which messages, files, Project sources, websites, or connected services matter?]
[Which source controls each type of claim?]

Output:
[Required format, sections, order, length, and level of detail.]

Boundaries:
[What must not change, be inferred, be accessed, or be executed?]
[Which actions require confirmation?]

Completion criteria:
[What must be checked before the task is complete?]

Missing information:
[Should ChatGPT ask, stop, or return a clearly labeled gap?]

Use only the fields that matter. A short, well-scoped task is better than a long prompt filled with rules that do not affect the result.

The first prompt is a starting point, not a contract that can never change. Review the result and send focused corrections. Add missing context, change the output structure, or correct the direction without restarting when the existing chat remains relevant.

Use one chat for one distinct outcome

Inside a Project, start a separate chat for each distinct result. Research, drafting, review, and implementation can share Project sources without mixing every branch into one transcript. This reduces irrelevant conversation context while preserving the Project’s reusable context.

Steer with explicit deltas

State what should change and what should remain unchanged.

Keep the evidence table and recommendation. Rewrite only the opening so the decision appears in the first paragraph. Do not change the figures or citations.

Review files through the appropriate viewer

When ChatGPT creates a document, presentation, spreadsheet, PDF, image, visualization, or Site, inspect the artifact itself. The chat summary is not a substitute for checking the rendered pages, slides, formulas, charts, labels, links, or interactive states.

Preserve only verified work

Do not add a generated answer to reusable Project context merely because it is convenient. Verify it first. Otherwise, an unsupported conclusion can become input to later chats and appear more authoritative because it was stored.

Tasks that use plugins, Browser, Computer Use, local files, shell commands, or scheduled execution can read or change systems outside the text response. Define the action boundary before the tool is used.

Separate three permission levels

1. Inspect: read or retrieve information without modifying the source.
2. Prepare: draft a message, change, form, or action for review without executing it.
3. Execute: perform the approved action in the named system.

Permission to inspect does not imply permission to modify. Permission to draft does not imply permission to send. Access to a website or connected service does not make its content trustworthy.

Use least privilege

• Name the exact account, service, app, site, folder, or record required.
• Limit the timeframe and data fields.
• Keep sensitive apps, tabs, and documents closed when they are not required.
• Review hostnames, permission prompts, recipients, amounts, dates, and destructive actions.
• Require confirmation immediately before a consequential or difficult-to-reverse step.
• After execution, verify the actual resulting state rather than relying only on the assistant’s statement.

External-action prompt pattern

Target:
[Exact service, account, site, app, folder, or record.]

Permitted access:
[What may be read or inspected?]

Permitted action:
[Inspect only / prepare a draft / execute a named action.]

Confirmation boundary:
[What requires my approval immediately before execution?]

Stop conditions:
[Wrong account, missing source, sign-in wall, CAPTCHA, unexpected recipient,
price change, permission change, deletion, or any scope expansion.]

OpenAI’s current guidance explicitly treats the first result as something to inspect, challenge, and improve. Fluency, citations, a strong model, high reasoning effort, or a completed tool run do not prove that the result is correct.

Verify the task

• Does the result answer the defined outcome?
• Is it written for the intended reader?
• Does it follow the requested structure and length?
• Are all completion criteria satisfied?

Verify the evidence

• Were the correct and current sources used?
• Does each material citation support the exact claim attached to it?
• Are names, dates, numbers, quotes, formulas, and product capabilities checked?
• Are unsupported assumptions and unavailable information visible?
• Did ChatGPT omit or underuse a required file, page, sheet, section, or source?

Verify the artifact

• Document or PDF: inspect every page, heading, table, citation, and page break.
• Presentation: inspect every slide, source, label, visual hierarchy, and overflow state.
• Spreadsheet: inspect every relevant sheet, formula, unit, filter, chart, and total.
• Image: inspect text, factual labels, dimensions, composition, and reference fidelity.
• Site or visualization: test interactions, links, responsive states, data assumptions, and source accuracy.
• Code: inspect the diff, run the relevant tests and checks, and confirm that the change matches the requested scope.

Verify actions

• Was the correct account, app, website, record, file, or recipient used?
• Did the action remain within the approved inspect, prepare, or execute boundary?
• Did any permission, deletion, purchase, message, or external commitment occur?
• Does the resulting external state match the intended action?

Legal, financial, medical, security, and other high-stakes uses require appropriate expert review. ChatGPT can support professional judgment; it does not replace the accountable reviewer.

1. Define: name the result, audience, format, and completion criteria.
2. Route: choose Chat, Work, or Codex.
3. Scope context: decide between a standalone chat and a Project; add only the required files, sources, memories, and connected context.
4. Configure: select the model and reasoning effort where available.
5. Authorize: add only required capabilities and define access, action, approval, and stop boundaries.
6. Execute: let ChatGPT perform the task while you steer material changes in scope or evidence.
7. Inspect: review the answer, sources, files, diffs, and external state.
8. Correct: return to the earliest wrong decision rather than adding a cosmetic patch to the final wording.
9. Preserve: save or reuse only outputs that passed the required checks.

This sequence keeps product controls subordinate to the work requirement. The model, Project, memory, plugin, browser, and prompt are inputs to a controlled process; none is a substitute for evidence or review.

The following OpenAI Learn pages were reviewed on August 18, 2026:

• Use ChatGPT
• Get started with ChatGPT Work
• Projects and chats
• Prompting
• Personalize ChatGPT
• Memories
• Models
• Web search
• Plugins
• Skills & Plugins
• Browser
• Computer Use
• Work with files
• Image generation
• ChatGPT Voice
• Visualizations
• Sites
• Scheduled tasks

Availability can depend on the plan, workspace, platform, region, administrator settings, and rollout. When the interface conflicts with an older screenshot or article, verify the current control against the current official documentation before updating the workflow.

Current-documentation boundary: this guide does not present Fast answers, Characteristics, Temporary Chat, or the older standard-Chat Instant / Medium / High / Extra High / Pro hierarchy as current stable cross-surface controls. Those labels are not documented as such in the current OpenAI Learn documentation set reviewed for this version. This does not prove that no account displays them; their present behavior and availability are NOT VERIFIED from the formal sources used here.