25 ChatGPT-5.5 Prompts for AI-Native Company Workflows: Onboarding, Account Intelligence, and Developer Integrations

How to Use These Prompts Without Turning Workflow Automation Into Unreviewed Autopilot

This prompt pack translates OpenAI’s September 1, 2026 AI-native workflow case studies into practical templates for company operations, customer intelligence, and developer integrations. OpenAI described three patterns: Basis turning onboarding into a reusable agent skill, Clay assigning persistent account workspaces and subagents, and Exa using Codex to turn integration signals into tested artifacts with human review before shipping or external communication. The prompts in this article are designed around those patterns rather than around vague “productivity” requests, which means each prompt should define a trigger, available evidence, allowed tools, expected artifact, escalation rule, and human approval point.

The most important operating principle is simple: the AI system may draft, classify, summarize, compare, prepare, test, and recommend, but named humans or accountable teams retain decision rights over policy exceptions, customer commitments, production deployment, clinical interpretation, financial terms, and external messages. This distinction matters because the OpenAI examples do not describe autonomous commercial decision-making. Basis retains human handling for exceptions, Clay uses agents to refresh context and produce priorities, and Exa has humans review work before shipping or communicating externally. Treat the prompts below as workflow scaffolding, not as a delegation of accountability.

For Enterprise AI Operating Model, How to Build a Multi-Agent Workflow with ChatGPT Work and GPT-5.6 Terra — Connecting Gmail, Slack, and GitHub for Automated Project Management is the most relevant adjacent resource. The multi-agent project-management guide demonstrates how Gmail, Slack, and GitHub can be coordinated under an explicit operating model, providing an implementation counterpart to the prompt patterns in this masterclass.

The Three Source Patterns Behind the Prompt Pack

1. The Basis Pattern: Convert a Demonstrated Process Into a Reusable Skill

OpenAI’s Basis example is useful because it starts with an observed human workflow, not with an abstract automation idea. The company converted a demonstrated onboarding process into a reusable agent skill with a trigger, known steps, required tools, and a definition of done, while keeping exception handling with humans. That is the correct pattern for onboarding because new-hire setup contains repeatable steps—collecting role context, surfacing required documents, generating checklists, identifying missing access—but also contains exceptions such as unusual employment status, region-specific policies, sensitive system access, or manager-specific instructions.

A reusable-skill prompt should therefore include five fields: “when to run,” “what evidence to inspect,” “what actions are permitted,” “what output must be produced,” and “when to stop.” A weak onboarding prompt says, “Help onboard this employee.” A production-ready prompt says, “Given the approved role description, start date, team, manager notes, and policy links, produce a role-specific onboarding checklist, identify missing information, and escalate any access request outside the standard role profile.” The second version creates a bounded skill with an exception path.

Recommended decision rule: automate the preparation of onboarding artifacts, but require human approval for access grants, policy exceptions, compensation-related content, regulated training substitutions, and any instruction that changes a worker’s contractual or compliance obligations.

2. The Clay Pattern: Maintain Persistent Account Workspaces Instead of Rebuilding Context Every Day

OpenAI described Clay as assigning a persistent workspace and subagent to each account. Those agents refresh account context overnight, and a coordinating agent produces daily priorities. Clay reported that the system saves roughly one hour of inbox triage per night. The transferable lesson is not the exact time savings, which will vary by organization, but the structure: account intelligence improves when the system maintains durable context, separates account-specific work from cross-account coordination, and produces a short list of priorities for humans to inspect.

For sales, success, partnerships, support, or research operations, the persistent-workspace prompt should define the account scope and evidence sources. Acceptable inputs might include CRM notes, customer emails that the organization is permitted to process, meeting transcripts, support tickets, product-usage summaries, contract milestones, or approved internal account plans. The prompt should instruct the model to separate verified facts from inferred risks, label stale information, and cite the source or location of each important claim. Without that evidence discipline, a “daily account brief” becomes a persuasive narrative that may hide outdated assumptions.

The workspace pattern also needs strict permission boundaries. A subagent assigned to an account should not be allowed to access unrelated accounts, infer confidential information from private channels, or draft commitments that exceed the account owner’s authority. For regulated or healthcare contexts, public-data tools and patient-context tools must be treated differently. OpenAI states that Healthcare Public Data is read-only, searches public healthcare sources, and must not receive protected health information. OpenAI also describes Epic access as a separate read-only plugin for approved healthcare and HIPAA-enabled Enterprise workspaces, requiring administrator configuration, individual Epic sign-in, and existing patient-chart permissions. If clinicians adapt account-workspace prompts for operational planning, they should verify outputs against the underlying sources and approved systems rather than treating the chat as the source of record.

3. The Exa Pattern: Turn Signals Into Tested Artifacts, Not Just Suggestions

OpenAI’s Exa example shows a more execution-heavy pattern: Codex monitors integration opportunities, gathers context, creates pull requests, runs tests, and prepares weekly updates from sources such as Slack and Notion, with human review before shipping or external communication. The operational insight is that developer workflows should not stop at “here are some ideas.” A mature prompt asks the system to preserve the signal, explain why it matters, identify affected code or documentation, produce a small implementation plan, create or prepare an artifact, run available tests, summarize results, and wait for review.

This signal-to-tested-artifact pattern is especially valuable for integrations because integration work is evidence-sensitive. A customer mention in Slack, a partner note in Notion, a recurring support issue, or a missing SDK example can be a legitimate signal, but it is not automatically a priority. The prompt should require the model to classify the signal type, identify the source, check whether the request is repeated or isolated, map it to existing product commitments, and state what evidence is still missing. Only after that should the system propose code, documentation, or issue-triage work.

For ChatGPT Agent Workflows, How to Build Multi-Agent Workflows with OpenAI Codex: Automating 8-Hour Tasks with Parallel Agent Orchestration is the most relevant adjacent resource. The Codex multi-agent orchestration guide explains how long tasks are divided, delegated, and cross-checked, helping teams move from isolated prompts toward repeatable supervised workflows.

The Control Surface: Evidence, Permissions, Tests, and Human Sign-Off

These controls should appear inside the prompt, not only in a policy document. A model cannot reliably follow a control it never receives in the work request, and a reviewer cannot easily audit an artifact if the prompt did not require citations, unresolved questions, or test results. For example, a prompt that asks for “top account risks” should also require “cite the source for each risk, mark any risk older than 30 days as stale unless refreshed, and list the account owner who must approve outreach.” The extra sentence turns a vague brief into an auditable operational artifact.

How to Customize the 25 Prompts for Your Company

Before using any prompt in this series, replace generic placeholders with your operating nouns. “Account” may mean customer, clinical site, payer, partner, vendor, donor, portfolio company, or internal business unit. “Onboarding” may mean employee onboarding, customer implementation, developer enablement, clinician training, or supplier intake. “Signal” may mean support ticket, repository issue, Slack thread, Notion note, CRM change, trial registry update, public policy update, or product telemetry summary. The workflow pattern stays consistent, but the evidence and approval rules must match the domain.

Use the following customization sequence before running a prompt in a live workspace. First, define the trigger in observable terms, such as “new customer marked implementation-ready,” “new integration request appears in approved channel,” or “account workspace refresh scheduled.” Second, list allowed sources and tools, including any systems that are explicitly off limits. Third, define the output artifact, such as checklist, account brief, exception report, implementation plan, pull request summary, or test log. Fourth, define the stop condition, especially when missing evidence, permission conflicts, security-sensitive code, PHI, contractual terms, or customer commitments appear. Fifth, assign the reviewer role that approves the next action.

Customization skeleton:
Trigger: [observable event that starts the workflow]
Scope: [team, account, system, repository, or workspace boundary]
Allowed evidence: [approved documents, channels, records, tickets, or code]
Disallowed evidence: [private, unrelated, regulated, or unapproved sources]
Permitted actions: [summarize, classify, draft, compare, prepare branch, run tests]
Prohibited actions: [commit externally, approve access, deploy, update records, send PHI to public tools]
Output artifact: [checklist, brief, plan, PR description, test report, escalation note]
Definition of done: [what complete means]
Escalation rule: [conditions requiring human review]
Reviewer: [accountable person or role]

For executives and operators, the customization step is where AI-native work becomes measurable. A reusable skill can be inspected for completion rate and exception categories. A persistent account workspace can be inspected for freshness, evidence quality, and priority accuracy. A signal-to-artifact workflow can be inspected for test pass rates, review changes, and rejected assumptions. Those metrics should be tied to the workflow design, not to a generic count of prompts sent or messages generated.

For developers, the customization step is also the security boundary. Do not give a coding agent broad repository or communication access just because the prompt says “run tests.” Start with the least permission necessary to inspect context and prepare a reviewable artifact, then expand only after the team understands the failure modes. For integration workflows, require the prompt to preserve the original signal, link the related issue or source note, identify affected files, summarize test commands and outcomes, and stop before merge or release unless your normal review process has approved the change.

The rest of this article provides 25 prompts organized around onboarding, account intelligence, and developer integrations. Each one follows the same underlying contract: define the trigger, constrain the evidence, scope the tools, produce a concrete artifact, run or request validation, and route decisions to humans. That contract is what makes the prompts reusable across departments without pretending that every workflow should be fully automated.

Prompts 1–10: Turn Observed Work Into Governed Onboarding Skills

These first ten prompts operationalize the reusable-skill pattern OpenAI described in its AI-native workflow case studies: observe a demonstrated process, extract stable steps, define triggers and tools, preserve exception handling for people, and review the workflow after use. Use them for internal enablement, employee onboarding, RevOps, support operations, clinical operations administration, engineering intake, or founder-led process capture, but keep the model inside a reviewed workflow rather than allowing it to make policy, access, hiring, clinical, financial, or production decisions on its own.

For Employee Onboarding Automation, 25 ChatGPT-5.5 Prompts for HR Professionals: Recruitment, Onboarding, Performance Reviews, and Employee Communications is the most relevant adjacent resource. The HR prompt collection includes recruitment, onboarding, performance, and employee-communication patterns that complement the reusable-skill design used here for consistent new-hire execution.

For Standard Operating Procedure Prompts, Codex Enterprise Prompts Masterclass: 40 Production-Ready Prompts for Long-Running Agent Workflows is the most relevant adjacent resource. The enterprise prompt masterclass focuses on long-running agent workflows and production constraints, offering detailed patterns for turning a written procedure into a testable, governed operating sequence.

1. Process Observation Prompt: Capture What the Expert Actually Does

Use case: Use this prompt while shadowing a high-performing employee, founder, clinician administrator, solutions engineer, support lead, or account manager. The goal is to document observed behavior, decisions, inputs, outputs, and handoffs before anyone tries to automate or standardize the process.

You are documenting an observed workflow, not redesigning it yet.

Process name: [PROCESS_NAME]
Expert role observed: [ROLE]
Business goal: [GOAL]
Observation notes or transcript: [NOTES]
Systems mentioned: [SYSTEMS]
Known constraints: [CONSTRAINTS]

Create an observation brief with:
1. Chronological steps the expert performed.
2. Inputs used at each step.
3. Decisions made and the evidence used.
4. Outputs produced.
5. Handoffs to other people or tools.
6. Ambiguous actions that require follow-up.
7. Risks if this process is automated too early.

Do not invent missing steps. Mark unknowns clearly.

Expected output: A structured observation brief with time-ordered steps, decision points, source materials, and unresolved questions. The most useful output separates what was directly observed from what was assumed by the observer.

Human decision: A manager or process owner decides whether the captured behavior reflects the approved way of working or merely one person’s workaround. Do not convert an observed shortcut into a standard operating procedure without approval.

Customization fields: Replace [PROCESS_NAME], [ROLE], [GOAL], [NOTES], [SYSTEMS], and [CONSTRAINTS] with the exact context. For regulated environments, include only approved, de-identified notes unless your workspace and data-handling policy explicitly permit the content.

2. SOP Extraction Prompt: Convert Notes Into an Auditable Procedure

Use case: Use this after at least one observation has been validated. It converts notes into a draft SOP with required inputs, sequence, owner, evidence, and quality checks, while preserving unknowns instead of smoothing them over.

Convert the following validated workflow notes into a draft standard operating procedure.

Workflow: [WORKFLOW]
Validated notes: [VALIDATED_NOTES]
Approved tools: [TOOLS]
Required records: [RECORDS]
Policy constraints: [POLICIES]
Excluded actions: [EXCLUSIONS]

Create:
1. Purpose and scope.
2. Roles and responsibilities.
3. Prerequisites.
4. Step-by-step procedure.
5. Evidence required at each step.
6. Quality checks.
7. Escalation points.
8. Items requiring policy-owner confirmation.

Use clear operational language. Do not add tools or permissions not listed.

Expected output: A draft SOP that a team lead, compliance owner, or operations manager can review line by line. The procedure should include evidence requirements, not just activity descriptions, so that later automation can be tested against real artifacts.

Human decision: The procedure owner approves, rejects, or edits the SOP. Legal, security, clinical governance, finance, or IT administrators may need to review sections involving regulated data, customer commitments, medical operations, procurement, or system access.

Customization fields: Fill [WORKFLOW] with a narrow process such as “first-week account executive onboarding” or “integration request triage.” Use [EXCLUSIONS] to block actions such as sending external messages, changing records, placing orders, granting access, or deploying code.

3. Reusable Skill Definition Prompt: Package a Workflow for Repeat Use

Use case: Use this to define a repeatable “skill” from an SOP. In OpenAI’s documented AI-native workflow pattern, the reusable skill contains a trigger, known steps, required tools, and a definition of done, while humans retain responsibility for exceptions.

Turn this SOP into a reusable AI-assisted skill specification.

SOP: [SOP_TEXT]
Skill users: [USERS]
Allowed tools and data sources: [ALLOWED_TOOLS]
Forbidden actions: [FORBIDDEN_ACTIONS]
Human approvers: [APPROVERS]
Exception categories: [EXCEPTIONS]

Return a skill card with:
1. Skill name.
2. When to use it.
3. When not to use it.
4. Required inputs.
5. Ordered steps.
6. Allowed tool use.
7. Outputs produced.
8. Definition of done.
9. Human approval gates.
10. Exception handoff rules.

Expected output: A concise skill card that can be reviewed, trained against, and reused by new employees or internal agents. It should read like an operational contract rather than a brainstorming note.

Human decision: Leadership decides whether the skill is safe and valuable enough to introduce into onboarding or daily work. The approval should include access review, data-classification review, and ownership assignment.

Customization fields: Use [ALLOWED_TOOLS] to name only approved repositories, documents, ticket queues, customer systems, or internal knowledge bases. Use [FORBIDDEN_ACTIONS] to prevent autonomous outreach, production changes, account edits, or unreviewed recommendations.

4. Trigger Design Prompt: Decide When the Workflow Should Start

Use case: Use this when a workflow fails because people do not know when to run it. Trigger design is especially important for onboarding check-ins, account intelligence refreshes, security reviews, integration monitoring, renewal preparation, and support escalations.

Design safe triggers for this reusable workflow.

Workflow or skill: [SKILL]
Business objective: [OBJECTIVE]
Possible trigger events: [EVENTS]
Available signals: [SIGNALS]
Noise risks: [NOISE]
High-risk false positives: [FALSE_POSITIVES]
High-risk false negatives: [FALSE_NEGATIVES]

Produce:
1. Recommended primary trigger.
2. Backup triggers.
3. Signals required before starting.
4. Signals that are insufficient alone.
5. Frequency limits.
6. Human confirmation requirements.
7. Logging requirements.
8. Test cases for trigger validation.

Expected output: A trigger specification that explains when the workflow begins, what evidence is required, and which signals are too weak to act on alone. Good trigger design reduces alert fatigue and prevents premature automation.

Human decision: The accountable owner decides whether the cost of missed triggers is worse than the cost of unnecessary runs. Security, sales, clinical, finance, and engineering workflows often have different risk tolerances.

Customization fields: Replace [EVENTS] with examples such as “new employee accepted offer,” “new enterprise account created,” “integration request mentioned in Slack,” or “customer renewal date within 60 days.” Replace [SIGNALS] with available, approved sources only.

5. Definition-of-Done Prompt: Make Completion Measurable

Use case: Use this when a process appears complete but downstream teams still find gaps. A definition of done should specify artifacts, checks, approvals, and evidence, not a vague statement that the task was “handled.”

Create a definition of done for this workflow.

Workflow: [WORKFLOW]
Primary output: [OUTPUT]
Downstream users: [DOWNSTREAM_USERS]
Required artifacts: [ARTIFACTS]
Quality checks: [CHECKS]
Approvals needed: [APPROVALS]
Failure examples: [FAILURES]

Return:
1. Completion criteria.
2. Required evidence.
3. Acceptance checklist.
4. Rejection criteria.
5. Owner for final approval.
6. Time or freshness requirements.
7. Audit trail requirements.
8. Examples of done and not done.

Expected output: A measurable completion standard that can be used by a new hire, manager, QA reviewer, or internal agent. The strongest definitions include both positive examples and rejection criteria.

Human decision: The downstream owner confirms whether the output is actually usable. For example, engineering may reject an integration brief without reproduction steps, while sales leadership may reject account intelligence without dated source evidence.

Customization fields: Use [ARTIFACTS] for the required deliverables: ticket, checklist, account note, test result, pull request, signed approval, training record, or escalation memo. Use [CHECKS] to include mandatory validation steps.

6. Access Mapping Prompt: Identify Permissions Before Automation

Use case: Use this before enabling any AI-assisted process that touches internal systems, customer records, source code, HR records, healthcare operations, finance tools, or support queues. Access mapping prevents a workflow from quietly depending on permissions the intended user should not have.

Map access requirements for this AI-assisted workflow.

Workflow: [WORKFLOW]
Steps: [STEPS]
Users or roles: [ROLES]
Systems involved: [SYSTEMS]
Data types: [DATA_TYPES]
Current permissions: [CURRENT_PERMISSIONS]
Policy constraints: [POLICIES]

Create an access map with:
1. System-by-system permissions needed.
2. Read versus write requirements.
3. Minimum necessary access.
4. Data classification concerns.
5. Segregation-of-duties risks.
6. Approval owner for each permission.
7. Access that should not be granted.
8. Review cadence for permissions.

Expected output: A permissions matrix showing who needs what access, why it is needed, and which permissions should remain unavailable. The output should distinguish read-only context from write actions because many safe workflows require evidence review but not system modification.

Human decision: IT, security, compliance, or application administrators decide whether to grant, deny, or limit access. The model can draft a map, but it cannot authorize permissions or override existing system controls.

Customization fields: Use [DATA_TYPES] to identify categories such as employee data, customer account notes, source code, billing records, support tickets, or regulated operational data. If healthcare information is involved, verify the workspace, permissions, and Business Associate Agreement status before including protected health information.

7. Exception Handling Prompt: Preserve Human Judgment

Use case: Use this to define what the workflow should do when inputs are incomplete, records conflict, the customer context is sensitive, policy is unclear, or the requested action exceeds the approved scope. Exception design is where many workflow automations either become safe or become brittle.

Design exception handling for this workflow.

Workflow: [WORKFLOW]
Normal path: [NORMAL_PATH]
Known exception types: [EXCEPTIONS]
Risk categories: [RISKS]
Escalation owners: [OWNERS]
Response time expectations: [SLAS]
Actions the AI must not take: [PROHIBITED_ACTIONS]

Return:
1. Exception taxonomy.
2. Detection signals for each exception.
3. Immediate safe response.
4. Information to collect before escalation.
5. Escalation path.
6. Required human decision.
7. Communication template for internal handoff.
8. Post-exception learning record.

Expected output: An exception playbook with detection signals, safe interim responses, and escalation instructions. It should instruct the workflow to stop, ask, or hand off when evidence is missing or authority is unclear.

Human decision: A designated owner decides the outcome of each exception. Examples include whether to contact a customer, approve nonstandard onboarding, interpret conflicting account notes, change a clinical operations workflow, merge code, or update a policy.

Customization fields: Replace [PROHIBITED_ACTIONS] with concrete boundaries such as “do not email the customer,” “do not update the CRM,” “do not change access,” “do not deploy,” or “do not include patient-identifying details in public-source research tools.”

8. Onboarding Checklist Prompt: Build Role-Specific Ramp Plans

Use case: Use this to turn approved SOPs and skill cards into a new-hire checklist. The checklist should connect learning tasks to observable work artifacts so managers can evaluate readiness without relying on vague confidence ratings.

Create a role-specific onboarding checklist.

Role: [ROLE]
Start date or week: [START_TIMELINE]
Approved SOPs and skills: [SOPS]
Required tools: [TOOLS]
Managers and buddies: [PEOPLE]
Compliance or policy requirements: [POLICIES]
First useful work outputs: [OUTPUTS]

Create:
1. Pre-start preparation.
2. Day 1 checklist.
3. Week 1 checklist.
4. Weeks 2-4 checklist.
5. Required system access.
6. Training artifacts to review.
7. Practice tasks.
8. Readiness evidence.
9. Manager review questions.
10. Blockers to escalate.

Expected output: A sequenced onboarding checklist that assigns tasks, tools, evidence, and review points. It should help the new hire produce useful work safely before they are expected to handle edge cases independently.

Human decision: The hiring manager confirms the ramp plan, adjusts timing for seniority, and decides when the employee can perform the workflow without close supervision. HR or compliance owners should review mandatory training requirements.

Customization fields: Use [OUTPUTS] to define early deliverables, such as “draft account brief,” “shadowed support response,” “tested internal integration,” “completed access request,” or “reviewed SOP with questions.”

9. New-Hire Coaching Prompt: Turn Work Artifacts Into Targeted Feedback

Use case: Use this after a new hire completes a practice task or first real workflow run. The prompt turns artifacts into coaching notes while keeping final performance evaluation with the manager.

Review this new-hire work artifact for coaching purposes.

Role: [ROLE]
Task assigned: [TASK]
Definition of done: [DEFINITION_OF_DONE]
New-hire artifact: [ARTIFACT]
Reference examples: [EXAMPLES]
Known constraints: [CONSTRAINTS]

Provide:
1. What the artifact did well.
2. Gaps against the definition of done.
3. Questions the manager should ask.
4. Specific coaching recommendations.
5. Practice exercise for the next attempt.
6. Risks if this gap appears in live work.
7. Items requiring manager judgment.

Do not make employment decisions. Focus on observable work quality.

Expected output: A coaching brief that compares the artifact against approved criteria. The output should identify concrete next steps, such as adding source citations, clarifying a handoff, checking access assumptions, or improving escalation language.

Human decision: The manager decides how to coach, whether the work meets expectations, and whether the new hire can move to the next stage of responsibility. The prompt must not be used as an automated employment decision system.

Customization fields: Use [EXAMPLES] for approved reference artifacts rather than random historical work. Use [CONSTRAINTS] to include customer sensitivity, regulated-data handling, tone requirements, or tool limitations.

10. Improvement Review Prompt: Update the Skill After Real Use

Use case: Use this at the end of an onboarding cycle, account workflow run, support sprint, integration review, or operational pilot. The objective is to improve the workflow using evidence, not anecdotes alone.

Run an improvement review for this AI-assisted workflow.

Workflow or skill: [WORKFLOW]
Review period: [PERIOD]
Runs completed: [RUNS]
Outputs produced: [OUTPUTS]
Exceptions encountered: [EXCEPTIONS]
Human review findings: [FINDINGS]
User feedback: [FEEDBACK]
Metrics available: [METRICS]

Create:
1. What worked reliably.
2. Repeated failure modes.
3. Trigger changes recommended.
4. SOP changes recommended.
5. Access or tool changes recommended.
6. Definition-of-done changes recommended.
7. Training updates for new hires.
8. Risks requiring owner review.
9. Proposed next experiment.
10. Change log entry.

Expected output: A practical retrospective with proposed edits to triggers, SOPs, access rules, training materials, and review gates. The best output distinguishes quick documentation fixes from changes that require policy, security, or leadership approval.

Human decision: The workflow owner decides which changes to adopt and records the final approved version. For developer workflows, humans still review tests, pull requests, and release decisions; for customer-facing workflows, humans still approve external communication and commercial commitments.

Customization fields: Replace [METRICS] with available evidence such as cycle time, rework count, exception volume, onboarding completion status, review comments, test outcomes, or escalation frequency. Do not fabricate metrics when instrumentation is incomplete; instead, add instrumentation as a follow-up action.

Prompts 11–20: Persistent Account Context, Evidence Refresh, and Developer Integration Workflows

Prompts 11–20 translate the documented Clay and Exa operating patterns into reusable work instructions. OpenAI describes Clay as assigning a persistent workspace and subagent to each account, refreshing account context overnight, and using a coordinating agent to produce daily priorities; OpenAI describes Exa as using Codex to monitor integration opportunities, gather context, create pull requests, run tests, and prepare weekly updates with human review before shipping or external communication. The prompts below preserve those control points: source evidence, scoped permissions, explicit uncertainty, test artifacts, and human approval before customer commitments or production changes.

11. Persistent Account Dossier Prompt: Keep Account Context Alive Between Meetings

For AI Sales Account Intelligence, Codex Plugins and the 90+ Integration Ecosystem: How Role-Specific AI Bundles Are Transforming Data Analytics, Sales, Creative Production, and Finance Workflows is the most relevant adjacent resource. The Codex integration-ecosystem analysis describes role-specific sales and data workflows, giving account teams a broader view of how persistent evidence can feed specialized commercial agents.

Prompt 11 — Persistent account dossier

You are maintaining an account dossier for: [ACCOUNT NAME].

Authorized sources:
- CRM records: [FIELDS OR REPORTS]
- Meeting notes: [LOCATION]
- Email or message summaries: [LOCATION]
- Call transcripts: [LOCATION]
- Product usage or support data: [LOCATION]
- Public company information: [ALLOWED SOURCES]

Build or update the dossier with these sections:
1. Account snapshot: industry, size, geography, current relationship, active opportunity or implementation stage.
2. Business objectives stated by the customer, with source citations.
3. Known pain points, blockers, and unresolved questions.
4. Buying committee or implementation committee members, including role, influence, stance, and last verified evidence.
5. Products, integrations, security requirements, procurement constraints, and timeline signals.
6. Prior commitments made by our team, separating confirmed commitments from informal discussion.
7. Evidence table with source, date, owner, confidence, and quote or paraphrased fact.
8. Open assumptions that require human validation.

Rules:
- Do not infer stakeholder authority unless a source supports it.
- Mark stale facts older than [AGE THRESHOLD] days.
- Separate customer-stated facts from our internal interpretation.
- Do not recommend next actions until the evidence table is complete.
- If regulated, confidential, or health-related data appears, flag it and follow workspace policy before including details.

Review gate: An account owner should verify the dossier before it is used for outreach, forecasting, executive briefings, or implementation planning. The model can organize facts, but it should not decide whether a stakeholder is a blocker, champion, economic buyer, or legal authority without source evidence.

12. Overnight Evidence Refresh Prompt: Update the Account Without Rewriting History

Use this prompt as a scheduled or end-of-day refresh for accounts with active motion. OpenAI’s Clay example includes agents refreshing account context overnight and a coordinating agent producing daily priorities; the important design choice is that new evidence is added as a dated delta rather than blended into an untraceable narrative. This makes it possible to audit why a priority changed, why a risk was raised, or why an opportunity was downgraded.

Prompt 12 — Overnight evidence refresh

Refresh the account dossier for [ACCOUNT NAME] using only the authorized sources listed below.

Sources to check:
- New CRM activity since [TIMESTAMP]
- New meetings or transcripts since [TIMESTAMP]
- New customer emails or approved message summaries since [TIMESTAMP]
- Support tickets or product signals since [TIMESTAMP]
- Approved public company updates since [TIMESTAMP]
- Internal implementation notes since [TIMESTAMP]

Return:
1. New evidence since last refresh, grouped by source.
2. Facts that changed, with old value, new value, source, and date.
3. Facts that became stale or contradicted.
4. New or changed open questions.
5. New risks, but only if tied to evidence.
6. Recommended human follow-ups for the account owner.
7. Items excluded because the source was unavailable, unauthorized, ambiguous, or outside policy.

Formatting:
- Use a delta log, not a rewritten full dossier.
- Label each item as confirmed, likely, uncertain, or needs human verification.
- Include no customer-facing language.
- Do not update forecast, stage, owner, close date, or external commitments. Suggest changes for review only.

Operational warning: A refresh workflow should fail closed when a source is unavailable. If the CRM export, message archive, or support queue cannot be checked, the output should say what was not inspected instead of implying full coverage. In healthcare or other regulated environments, do not route protected or restricted information into public-data tools; OpenAI’s healthcare guidance explicitly separates public data sources from authorized patient-chart access.

13. Buying-Committee Gap Prompt: Identify Missing Stakeholders and Unsupported Assumptions

Use this prompt when the team believes it knows the buying committee but the evidence is scattered across calls, CRM fields, executive notes, and implementation conversations. The goal is to expose gaps, not to manufacture a perfect org chart. A model can help compare role coverage against a standard enterprise buying pattern, but the account owner must confirm titles, authority, and political dynamics before acting.

Prompt 13 — Buying-committee gap analysis

Analyze the current buying or implementation committee for [ACCOUNT NAME].

Inputs:
- Current stakeholder list: [PASTE OR ATTACH]
- Opportunity stage: [STAGE]
- Product or deployment type: [DESCRIPTION]
- Known requirements: [SECURITY, LEGAL, PROCUREMENT, TECHNICAL, CLINICAL, FINANCE, OPERATIONS]
- Evidence sources: [CRM, NOTES, TRANSCRIPTS, EMAIL SUMMARIES]

Tasks:
1. Create a stakeholder matrix with name, title, function, role in decision, stance, influence level, last interaction, and evidence.
2. Identify likely missing functions for this type of decision, such as economic buyer, technical evaluator, security reviewer, legal/procurement reviewer, executive sponsor, operations owner, end-user representative, or implementation lead.
3. Separate confirmed gaps from hypothesized gaps.
4. List questions the account owner should ask to confirm each gap.
5. Recommend the safest next internal action and the safest next customer-facing question.

Constraints:
- Do not label a person as a blocker or champion without evidence.
- Do not suggest bypassing a stakeholder.
- Do not draft manipulative language.
- Do not assume purchasing authority from seniority alone.

Decision rule: Treat “unknown” as a first-class status. A missing security reviewer, unconfirmed procurement process, or absent implementation owner is not a reason to panic; it is a reason to ask a precise question before the deal or deployment reaches a late-stage surprise.

14. Customer-Question Tracking Prompt: Turn Loose Questions Into Owned Work Items

Use this prompt after discovery calls, technical workshops, security reviews, procurement discussions, or implementation check-ins. The purpose is to convert customer questions into trackable obligations with owners, evidence requirements, due dates, and approval status. This is especially important when several teams answer the same customer: sales, solutions, support, legal, security, product, and engineering may each own part of the response.

Prompt 14 — Customer-question tracker

From the materials below, extract every customer question, request, objection, and promised follow-up.

Materials:
[PASTE NOTES, TRANSCRIPT EXCERPTS, EMAIL SUMMARY, OR TICKET LIST]

Create a table with:
- Question or request
- Customer stakeholder who asked
- Date asked
- Context and why it matters
- Internal owner
- Required evidence or source of truth
- Response status: unanswered, drafted, under review, answered, blocked, or no action needed
- Due date or urgency signal
- Risk if unanswered
- Customer-facing response draft only if enough approved information exists

Rules:
- Preserve exact wording when available.
- Mark implied questions separately from explicit questions.
- Do not invent product capabilities, roadmap dates, legal positions, security claims, prices, or implementation timelines.
- If a response requires legal, security, clinical, compliance, or engineering review, label it as review-required.
- If the answer depends on customer-specific configuration, state the dependency instead of giving a generic promise.

Review gate: The account owner should approve prioritization, and domain owners should approve substantive answers. A generated draft can accelerate response preparation, but external communication should not be sent until the responsible human confirms accuracy, tone, and authority.

15. Deal-Risk Signal Prompt: Detect Evidence-Backed Risks Without Forecast Theater

Use this prompt before pipeline reviews, renewal meetings, executive briefings, or implementation health checks. The model should identify risk signals from evidence, not generate a pessimistic or optimistic narrative to fit a forecast category. This prompt is useful when teams want earlier warning on risks such as silent stakeholders, unanswered security questions, delayed procurement, unresolved integration dependencies, support dissatisfaction, or ambiguous success criteria.

Prompt 15 — Deal-risk signal review

Assess evidence-backed risk for [ACCOUNT NAME] and [OPPORTUNITY OR DEPLOYMENT].

Use these inputs:
- Account dossier: [LINK OR CONTENT]
- Latest delta log: [LINK OR CONTENT]
- Customer-question tracker: [LINK OR CONTENT]
- CRM stage and next step: [CONTENT]
- Support or implementation signals: [CONTENT]

Return:
1. Risk register with risk, evidence, severity, likelihood, affected outcome, owner, and proposed mitigation.
2. Positive signals that reduce risk, with evidence.
3. Contradictory signals that require human interpretation.
4. Risks that are commonly assumed but not supported here.
5. Recommended review questions for the account team.
6. Escalations that may be warranted, but mark them as recommendations only.

Rules:
- Do not change the forecast category.
- Do not recommend discounts, legal concessions, roadmap commitments, or executive escalation without labeling them as human decisions.
- Do not treat lack of recent activity as risk unless the expected cadence is known.
- Cite the source and date for every risk signal.

Operational warning: Risk scoring can create false confidence if the input coverage is uneven. A well-instrumented support channel and a poorly documented executive conversation should not be weighted equally. Ask the model to show evidence gaps so the team understands where it is blind.

16. Daily Priority Brief Prompt: Coordinate Account Actions Across Teams

Use this prompt at the start of the day to produce a concise operating brief for an account owner, customer-success manager, solutions engineer, implementation lead, or founder. OpenAI’s Clay case study describes a coordinating agent that produces daily priorities from refreshed account context; this prompt keeps that pattern bounded by evidence and human judgment. The output should be a decision-support brief, not an autonomous task dispatcher.

Prompt 16 — Daily priority brief

Prepare a daily priority brief for [ROLE] covering these accounts:
[ACCOUNT LIST]

Inputs available:
- Latest account dossiers
- Overnight refresh logs
- Customer-question trackers
- Calendar for today
- Open internal tasks
- Support or implementation alerts
- Approved company priorities

For each account, provide:
1. What changed since yesterday.
2. The most important customer-facing priority.
3. The most important internal priority.
4. Questions that need an answer before the next meeting.
5. Risks requiring attention today.
6. Suggested preparation for scheduled meetings.
7. Items to ignore or defer, with rationale.
8. Confidence level and missing sources.

Constraints:
- Keep the brief action-oriented and source-cited.
- Do not create calendar events, send messages, update CRM, or assign tasks unless separately authorized.
- Do not prioritize solely by deal size; include urgency, risk, customer commitment, and dependency timing.
- Flag any recommendation that requires manager, legal, security, product, or engineering approval.

Example acceptance criterion: A useful daily brief should let a human decide the next three actions in less than a few minutes because the evidence, dependency, and owner are visible. It should not hide uncertainty behind confident prose.

17. Integration-Opportunity Discovery Prompt: Find Signals Worth Engineering Review

Use this prompt to scan approved internal sources for integration ideas, repeated customer requests, partner references, support friction, or developer adoption blockers. OpenAI describes Exa using Codex to monitor integration opportunities from sources such as Slack and Notion, gather context, create pull requests, run tests, and prepare weekly updates. This prompt covers only discovery and triage; it does not authorize implementation or customer commitments.

Prompt 17 — Integration-opportunity discovery

Identify possible integration opportunities from the approved sources below.

Sources:
- Customer calls or notes: [LOCATION]
- Support tickets: [LOCATION]
- Sales or success notes: [LOCATION]
- Internal docs: [LOCATION]
- Developer feedback: [LOCATION]
- Repository issues or discussions: [LOCATION]
- Public documentation requests: [LOCATION]

Return an opportunity list with:
- Integration or workflow requested
- Customer or internal source
- Frequency of requests
- Use case and user persona
- Current workaround
- Business impact evidence
- Technical surface area if known
- Existing related code, docs, APIs, or examples
- Unknowns requiring engineering review
- Suggested next step: ignore, monitor, investigate, scope, or propose

Rules:
- Do not rank an opportunity as strategic without evidence.
- Do not promise availability, pricing, partnership, support level, or timeline.
- Separate customer demand signals from internal enthusiasm.
- Identify whether the request is for a product integration, documentation improvement, sample app, API enhancement, or support workflow.

Decision rule: Promote an opportunity from “monitor” to “investigate” only when there is evidence of repeated demand, meaningful customer impact, strategic account relevance, or a clear reduction in support or implementation friction. One loud request can matter, but the brief should explain why.

18. Integration Evidence Collection Prompt: Build the Case Before Scoping Code

Use this prompt after a possible integration has passed initial discovery. The goal is to gather enough evidence for product, engineering, security, support, and go-to-market reviewers to decide whether scoping is worthwhile. Evidence collection should happen before implementation planning so the team does not spend engineering time solving a poorly defined or commercially unsupported problem.

Prompt 18 — Integration evidence collection

Build an evidence packet for the proposed integration: [INTEGRATION OR WORKFLOW NAME].

Collect and organize:
1. Customer evidence: requests, quotes, account names if permitted, dates, and use cases.
2. Internal evidence: support tickets, sales notes, implementation notes, product feedback, or developer-relations observations.
3. Technical evidence: existing APIs, SDKs, documentation, auth requirements, rate-limit considerations if documented, data models, and related code.
4. Risk evidence: security, privacy, compliance, reliability, maintenance, dependency, or support concerns.
5. Alternatives: manual workaround, documentation fix, partner-built option, no-build option, or configuration change.
6. Success criteria: what measurable outcome would justify the work.
7. Missing evidence: what must be verified before scoping.

Rules:
- Cite every claim to a source.
- Do not include secrets, credentials, private keys, tokens, or unnecessary personal data.
- Do not assume a third-party API permits a use case unless documentation or approval supports it.
- If healthcare, financial, education, or other regulated data may be involved, flag compliance review before implementation.

Review gate: A product or engineering lead should review the evidence packet before anyone creates a branch or implementation plan. Codex or another coding agent can help assemble context, but it should not decide that the company will build, support, or announce an integration.

19. Implementation Scoping Prompt: Convert Approved Evidence Into a Bounded Plan

Use this prompt only after the evidence packet has been reviewed and the team agrees that scoping is appropriate. The output should define a narrow, testable implementation path: files likely affected, interfaces, assumptions, acceptance criteria, review owners, and non-goals. This mirrors the Exa-style progression from signal to context to pull request, while preserving human review before shipping.

Prompt 19 — Implementation scoping

Create an implementation scope for: [APPROVED INTEGRATION OR WORKFLOW].

Inputs:
- Approved evidence packet: [LINK OR CONTENT]
- Product decision or scoping approval: [CONTENT]
- Repository or codebase context: [AUTHORIZED LOCATION]
- Existing docs and examples: [AUTHORIZED LOCATION]
- Constraints: [SECURITY, PERFORMANCE, PRIVACY, COMPATIBILITY, SUPPORT, RELEASE]

Produce:
1. Problem statement and user story.
2. Non-goals and out-of-scope requests.
3. Proposed architecture or workflow at a high level.
4. Files, modules, docs, examples, or tests likely affected.
5. Data handled, permissions required, and secrets that must never be exposed.
6. External dependencies and assumptions to verify.
7. Acceptance criteria.
8. Rollback or disablement considerations.
9. Reviewers needed: product, engineering, security, docs, support, legal, or compliance.
10. Open questions blocking implementation.

Rules:
- Do not write production code yet unless explicitly authorized.
- Do not change public documentation or customer-facing claims.
- Do not introduce new permissions, data flows, or dependencies without flagging them.
- Prefer the smallest testable increment over a broad redesign.

Operational warning: Scoping should identify permission boundaries before code generation begins. If the integration touches customer data, authentication flows, clinical context, financial records, or administrative controls, the plan should call for the appropriate internal review rather than treating the issue as an implementation detail.

20. Test-Plan Design Prompt: Require Evidence That the Integration Works Before Review

Use this prompt before a pull request is opened or before an implementation branch is considered ready for review. OpenAI’s Exa example includes running tests and preparing updates with human review before shipping or external communication. A good test plan gives reviewers confidence that the change is bounded, observable, reversible where appropriate, and aligned with the approved scope.

Prompt 20 — Integration test-plan design

Design a test plan for the proposed implementation: [INTEGRATION OR WORKFLOW].

Inputs:
- Implementation scope: [LINK OR CONTENT]
- Acceptance criteria: [CONTENT]
- Relevant code or docs context: [AUTHORIZED LOCATION]
- Known risks: [SECURITY, PRIVACY, RELIABILITY, PERFORMANCE, COMPATIBILITY]
- Supported environments: [LIST IF KNOWN]

Create a test plan with:
1. Unit tests for core logic.
2. Integration tests for external or internal interfaces.
3. Authentication and permission checks, if applicable.
4. Error-handling and retry behavior to verify.
5. Data-handling tests, including minimization and redaction where required.
6. Regression tests for affected existing behavior.
7. Documentation or example validation.
8. Manual QA checklist for reviewer execution.
9. Observability or logging checks, excluding sensitive data.
10. Pass/fail criteria and evidence artifacts to attach to the pull request.

Rules:
- Do not claim tests passed unless actual test output is provided.
- Do not skip security, privacy, or permission tests because the change is small.
- Do not use production secrets, real patient data, or unnecessary personal data in tests.
- Clearly mark tests that cannot be run in the current environment and explain what human reviewer must verify.

Review gate: The pull request or implementation package should include the approved scope, evidence packet, test plan, actual test output where available, and a concise reviewer note listing risks and unresolved questions. Human reviewers should retain authority over merge, release, customer notification, and any production deployment.

Prompts 21–25: Review, Communicate, Measure, and Govern the Workflow

Prompts 21–25 close the operating loop that began with onboarding skills, persistent account context, and developer integration work. The goal is not to let a model merge code, announce commitments, or reassign authority. The goal is to make review packets, evidence trails, status updates, retrospectives, and decision-right audits easier for responsible humans to inspect before action.

21. Pull-Request Preparation Prompt: Turn the Implementation Plan Into a Reviewable Change Packet

Use this prompt after an approved implementation scope exists and before a human reviewer is asked to evaluate code. It follows the pattern OpenAI described in Exa’s workflow, where Codex gathers context, prepares pull requests, runs tests, and leaves review to humans before shipping or external communication. The output should be a review packet, not a merge decision.

Act as a pull-request preparation assistant for a bounded developer workflow.

Approved implementation scope:
[PASTE APPROVED SCOPE]

Changed files or planned changes:
[PASTE DIFF SUMMARY, FILE LIST, OR BRANCH NOTES]

Evidence sources:
[LINK OR PASTE ISSUE, CUSTOMER SIGNAL, INTERNAL SPEC, DESIGN NOTE, TEST PLAN]

Test commands available:
[LIST TEST COMMANDS OR SAY "NOT YET KNOWN"]

Prepare a pull-request packet with:
1. One-sentence purpose of the change.
2. User or customer problem being addressed, with source references.
3. Files changed and why each file matters.
4. Expected behavior before and after the change.
5. Tests that should be run before review.
6. Risks, rollback considerations, and unresolved questions.
7. Items that require human reviewer judgment.

Do not claim that the change is ready to merge unless test evidence and reviewer approval are supplied. Do not invent acceptance criteria, customer commitments, or production deployment status.

The best output is concise enough for a reviewer to scan but specific enough to prevent “rubber stamp” review. Require source references for every stated reason for the change. If the assistant cannot connect a code change to an approved scope item, it should flag the gap rather than rationalize the change after the fact.

22. Test-Result Review Prompt: Separate Passing Evidence From Residual Risk

Use this prompt after tests have been executed and logs are available. It is especially useful when a workflow produces multiple artifacts: unit-test output, integration-test output, screenshots, CI logs, lint results, and manual verification notes. The prompt should classify evidence, not reinterpret failing tests as acceptable.

Act as a test-result reviewer. Your job is to summarize evidence for a human engineer, not to approve release.

Implementation goal:
[PASTE GOAL]

Test plan:
[PASTE TEST PLAN]

Test results and logs:
[PASTE RAW OR SUMMARIZED RESULTS]

Known constraints:
[PASTE ENVIRONMENT LIMITATIONS, MOCKS, SKIPPED TESTS, OR FLAKY AREAS]

Create a test-review brief with:
1. Tests run, including commands or verification method.
2. Passes, failures, skips, warnings, and incomplete checks.
3. Which acceptance criteria are supported by evidence.
4. Which acceptance criteria remain unproven.
5. Possible causes for failures or gaps, labeled as hypotheses.
6. Recommended next actions for the human owner.
7. A release-readiness statement using only these labels:
   - "Evidence complete for reviewer inspection"
   - "Evidence incomplete"
   - "Blocked by failing or missing tests"

Do not mark the work as releasable. Do not hide skipped tests. Do not convert hypotheses into facts.

For Codex Developer Workflows, OpenAI Open-Sources the Codex Agent Harness: Architecture, SDKs, App-Server, and What Developers Can Build is the most relevant adjacent resource. The Codex agent-harness architecture article explains the app-server and SDK foundations developers can use to convert integration opportunities into controlled, observable tools.

Operational warning: A green test run is not the same as business approval, security approval, or production readiness. Treat tests as evidence for a reviewer, not as a substitute for code ownership, change management, incident-risk evaluation, or customer-commitment review.

23. Announcement Drafting Prompt: Communicate What Changed Without Overpromising

Use this prompt when a change has passed the appropriate internal review and a team needs a draft for release notes, customer success, support, sales engineering, or internal enablement. The assistant may help convert technical detail into audience-specific language, but a human owner must verify accuracy, scope, timing, and any external claims.

Act as an announcement drafting assistant for a reviewed product or workflow change.

Approved facts:
[PASTE ONLY APPROVED FACTS]

Audience:
[INTERNAL TEAM, CUSTOMER SUCCESS, SUPPORT, SALES ENGINEERING, CUSTOMER ADMINS, DEVELOPERS]

What is changing:
[PASTE VERIFIED CHANGE]

What is not changing:
[PASTE EXCLUSIONS, LIMITATIONS, OR NON-GOALS]

Availability or rollout status:
[PASTE APPROVED STATUS ONLY]

Required caveats:
[PASTE SECURITY, PRIVACY, DATA, SUPPORT, OR COMPLIANCE CAVEATS]

Draft:
1. A short announcement.
2. A technical note for operators or developers.
3. A support-facing FAQ with 5 likely questions.
4. A list of claims that require legal, security, product, or clinical review before external use.
5. A "do not say" section that prevents unsupported commitments.

Do not invent dates, customers, pricing, performance numbers, certifications, permissions, medical claims, or availability. If a fact is missing, write "Needs owner confirmation."

For healthcare, regulated, or enterprise-admin audiences, the “do not say” section is not optional. For example, workflows that reference public healthcare data must not suggest that public-source tools can receive protected health information or access patient charts. If an Epic-connected workflow is involved, the announcement must reflect the approved workspace configuration, read-only access, individual sign-in, and existing chart permissions described by OpenAI, and it must not imply that the assistant can place orders, update records, or expand access.

For commercial announcements, separate availability from intent. A draft can say “planned,” “in review,” or “available to this workspace” only if those statuses are supplied by the owner. If the assistant lacks an approved rollout note, it should create a question for product operations rather than filling the gap with optimistic language.

24. Weekly Workflow Evaluation Prompt: Decide Whether the Automation Is Actually Helping

Use this prompt once a week for any AI-native workflow that has real users. The evaluation should compare outputs against measurable expectations: time saved, fewer handoffs, better evidence trails, faster review packets, fewer missed follow-ups, or lower rework. Do not rely on sentiment alone; pair user comments with observable artifacts.

Act as a weekly workflow evaluator.

Workflow name:
[PASTE NAME]

Original workflow goal:
[PASTE GOAL]

Definition of done:
[PASTE DEFINITION OF DONE]

This week's runs:
[PASTE RUN COUNT, EXAMPLES, LINKS, OR SUMMARIES]

Evidence:
[PASTE OUTPUTS, REVIEW NOTES, TEST RESULTS, HANDOFF TIMES, EXCEPTIONS, USER FEEDBACK]

Known incidents or near misses:
[PASTE DETAILS]

Evaluate:
1. Whether the workflow met its definition of done.
2. Evidence of saved time, reduced rework, or improved decision quality.
3. Evidence of new risk, confusion, or hidden manual cleanup.
4. Top recurring failure modes.
5. Permission or data-boundary concerns observed this week.
6. Recommended changes for next week, ranked by impact and risk.
7. A stop/continue/change recommendation for the workflow owner.

Use only supplied evidence. If metrics are missing, propose what to measure next week rather than guessing.

The weekly review should include at least one “bad run” when available. High-quality workflow evaluation looks at failures, exceptions, and user overrides because those are the places where an apparently useful assistant may be shifting work to reviewers. If a prompt saves drafting time but doubles verification time, the workflow may need stricter evidence inputs, narrower scope, or a clearer definition of done.

25. Decision-Rights Audit Prompt: Confirm Humans Still Own the Important Calls

Use this prompt monthly, after a major workflow change, or before expanding a workflow to a new team. It identifies whether a system is drifting from “assistant prepares evidence” into “assistant effectively decides.” This matters for engineering releases, account priorities, clinical or regulated workflows, security-sensitive tasks, and any process that can create customer commitments.

Act as a decision-rights auditor for an AI-assisted workflow.

Workflow description:
[PASTE DESCRIPTION]

Current users and roles:
[PASTE ROLES]

Tools, plugins, repositories, systems, or data sources used:
[PASTE LIST]

Actions the assistant can take:
[PASTE ACTIONS]

Actions humans take:
[PASTE ACTIONS]

Approval requirements:
[PASTE POLICY OR CURRENT PRACTICE]

Audit the workflow:
1. List every decision made or influenced by the assistant.
2. Classify each decision as:
   - evidence preparation
   - recommendation
   - low-risk execution
   - high-impact decision
   - external commitment
3. Identify who has final authority for each high-impact decision.
4. Identify any place where approval is implied but not explicit.
5. Identify permissions that exceed the workflow's purpose.
6. Identify data types that should be excluded or redacted.
7. Recommend control changes before broader rollout.

Do not assume permission because a tool is technically accessible. Do not approve autonomous production deployment, customer commitments, clinical decisions, or access expansion.

The audit should produce a rights map that an executive, administrator, or team lead can understand. A healthy workflow has explicit human owners for scope approval, merge approval, external messaging, security exceptions, account commitments, and regulated-data use. If ownership is ambiguous, expansion should wait until authority is documented.

Rollout Controls for Prompts 21–25

Recommendation: start with read-only evidence gathering and review preparation before enabling any tool-enabled execution. OpenAI’s AI-native workflow examples show a progression from reusable skills, to persistent context, to tool-enabled execution with tests and human review. Follow that sequence rather than deploying pull-request, announcement, and decision-audit workflows to every team at once.

1. Pilot with one workflow owner. Select a narrow use case such as PR packet preparation for one repository or weekly evaluation for one account team.
2. Define allowed inputs. Specify which issue trackers, documents, logs, repositories, or account notes may be used. Exclude secrets, credentials, unnecessary personal data, and regulated data unless the workspace and use case are explicitly approved.
3. Require artifact retention. Store prompts, outputs, source links, test logs, review comments, and approval decisions where the team can audit them later.
4. Run shadow mode first. Have the assistant generate packets while the existing process continues. Compare output quality before replacing any manual step.
5. Expand only after review. Use the weekly evaluation prompt to decide whether to continue, change, or stop before adding teams or permissions.

Permission Boundaries and Data Handling Rules

Permission design should match the workflow’s purpose. A PR-preparation assistant usually needs repository context and test output, not production credentials. An announcement assistant needs approved facts, not private customer contracts. An account-intelligence workflow needs authorized account notes, not unrestricted inbox or file access. Administrators should treat “can access” and “should use” as separate questions.

For healthcare-related workflows, keep public evidence and patient context separated. OpenAI states that Healthcare Public Data searches read-only public sources and does not access patient charts; it also warns not to send protected health information to public sources. OpenAI describes the Epic plugin as a separate read-only option for approved ChatGPT for Healthcare and HIPAA-enabled Enterprise workspaces, requiring administrator configuration, individual Epic sign-in, and enforcement of existing chart permissions. Any healthcare workflow must be verified against the organization’s approved configuration and underlying source records.

Measurable Gates Before Broader Deployment

Set rollout gates that can fail. A practical threshold might require that every PR packet include linked scope, changed-file rationale, test evidence, and unresolved questions before the workflow moves beyond pilot. An announcement workflow might require owner-approved facts, explicit exclusions, and a “do not say” list before a draft can leave the product team. A decision-rights workflow should require named human approvers for high-impact decisions before tool permissions expand.

Do not use model confidence as a quality metric. Use reviewer-visible evidence: fewer missing links, fewer unsupported claims, faster review cycles, lower rework, fewer permission escalations, and clearer exception handling. If the workflow cannot be measured from artifacts, it is not ready for scale.

Iteration Rules for Prompt Owners

• Change one variable at a time. If you revise the prompt, data source, and approval path simultaneously, you will not know which change improved or harmed the workflow.
• Promote recurring exceptions into rules. If reviewers repeatedly correct the same unsupported claim, add an explicit prohibition or required evidence field.
• Retire stale context. Persistent workspaces should refresh evidence without preserving outdated assumptions as if they were facts.
• Escalate ambiguity. When scope, permission, or authority is unclear, the assistant should create a question for the owner rather than proceed.
• Keep humans on consequential decisions. Code merge, production rollout, customer commitment, clinical interpretation, access expansion, and security exception decisions require accountable human owners.

Conclusion: Make the Assistant Prepare the Work, Not Own the Outcome

The final five prompts turn AI-native workflow design into an inspectable operating system: prepare pull requests, review test evidence, draft careful announcements, evaluate weekly performance, and audit decision rights. Used together, they help teams convert signals into artifacts while preserving review, source grounding, permissions, and accountability. The durable pattern is simple: let the assistant collect, structure, compare, and draft; require humans to approve, ship, commit, and govern.

Useful Links

• OpenAI: How AI-native companies turn workflows into operating capability
• OpenAI product release notes
• ChatGPT release notes
• OpenAI Help: Using Healthcare Public Data in ChatGPT and Codex
• OpenAI Help: Using the Epic plugin with ChatGPT and Codex
• OpenAI Help: ChatGPT for Healthcare