How to Create a Custom GPT: Paste-Ready Field Checklist

Custom GPTs are named ChatGPT assistants with standing instructions, optional conversation starters, and optional knowledge files. Creating one means filling builder fields in chatgpt.com when your workspace allows it, then previewing before teammates rely on the GPT. This guide is a how-to checklist, not a what-is explainer. For definitions and when to build versus skip, read what-is-a-custom-gpt. Here you get a field-by-field paste order, a pre-builder prep list, preview steps, and drafting on PromptMake before you touch OpenAI. PromptMake at https://promptmake.net/custom-gpt-generator outputs config text for name, description, instructions, and starters. It does not publish GPTs inside ChatGPT, upload knowledge PDFs to OpenAI, or change workspace admin settings. You copy fields into the builder yourself. Guests get about three runs per day on generator paths. Free accounts get about five. You leave with a repeatable create workflow and an FAQ.

Before you open the builder: prep checklist

Confirm create rights on your OpenAI workspace. As of mid-2026, new GPT creation often requires Business, Enterprise, or Edu plans when admins allow it. Personal accounts may edit existing GPTs while facing limits on new creates. Check OpenAI Help before you schedule a team rollout.

Pick one repeat job that stays inside ChatGPT weekly: support reply editing, research briefs, lesson plans, brand tone passes, internal macro drafting.

Write a three-sentence seed offline before any UI work. Sentence one: outcome. Sentence two: audience and tone. Sentence three: hard fences such as no legal advice, no invented pricing, ask when ticket id is missing.

Gather knowledge files only if the job needs long reference docs you would otherwise paste every week. Style guides, product sheets, and FAQ PDFs belong in knowledge. Ticket-specific facts belong in the live chat message, not in standing instructions.

Name an owner who will update instructions when policy changes. GPTs rot when nobody owns the Configure tab.

Access and admin gates

Ask IT whether browsing, code interpreter, or external actions are allowed for client-data workflows before you enable capabilities.

Confirm whether the GPT will be workspace-wide in Explore or a personal experiment. Label experiments in the name so teammates know fences may be loose.

If create is blocked, stop here. Policy beats prompting. Use what-is-a-custom-gpt to explain the product to stakeholders while admins resolve access.

One job per GPT rule

Do not build one GPT that does support, sales, and legal review. Split by outcome so instructions stay short and preview tests stay honest.

If two jobs share eighty percent of rules, still split when output formats differ. Support replies and executive briefs need different starters and headers.

Step 1: Name and description fields

Open the GPT builder Create or Configure path on chatgpt.com. Start with name and description because humans search before the model reads instructions.

Name checklist: say the job in plain language, front-load the task noun, avoid cute puns teammates cannot guess, keep stable across releases.

Good name examples: Support Reply Editor, QBR Slide Outliner, API Error Explainer. Weak names: Magic Helper 3000, Bob's Bot.

Description checklist: two to four sentences for humans browsing Explore. State who it is for, what tasks it handles, one benefit, and one boundary if needed.

Description is not a second instructions field. Do not paste the full workflow into description. Users read description once. Instructions load every chat.

Paste name and description from https://promptmake.net/custom-gpt-generator if you drafted there. Edit until a new hire would pick the right GPT from search.

Name field paste-ready example

Name: Customer Support Reply Editor. Short, searchable, stable.

If the job splits into tiers, make two GPTs: Support Reply Editor L1 and Support Reply Editor Escalation. Do not stretch one name across unrelated tasks.

Description field paste-ready example

Description: For support agents who paste ticket text and need on-brand replies with empathy and clear next steps. Returns subject line, body, and internal note. Internal use only. Does not replace legal review on billing disputes.

Mention boundaries when regulated data or legal risk exists. Boundaries in description set human expectations before the first message.

Step 2: Instructions field (the contract)

Instructions are the standing system prompt for this GPT. This field carries most of the quality bar. Everything else supports it.

Instructions checklist: role, primary job, numbered workflow steps, required output headers, tone rules, hard fences, missing-info behavior.

Use markdown headings inside the field when reviewers need scan-friendly diffs: Role, Workflow, Output format, Fences, When info is missing.

Role example: You are an internal support editor for Acme SaaS. You rewrite agent drafts for clarity and warmth. You do not invent refund policy.

Workflow example: When the user pastes a ticket, extract customer ask, identify product area, draft reply, add internal note for CRM.

Output format example: Return three sections with headers: Subject, Customer reply, Internal note. Use bullet internal note when multiple systems are involved.

Fences example: Never claim a refund is approved. Never cite pricing not in knowledge files. If ticket id is absent, ask once before drafting.

Keep ticket names, account ids, and dates out of instructions. Those belong in the user message each session.

Instructions layering

Layer one: durable rules and workflow in Instructions. Layer two: evidence in knowledge files. Layer three: ticket facts in the live user message.

Reversing layers causes drift. Do not put critical fences only in a PDF the model may not retrieve every turn.

If a rule must apply every chat, it lives in Instructions. If a rule is reference material, it lives in knowledge with a filename callout in Instructions.

Paste-ready instructions skeleton

Role: one paragraph. Workflow: five numbered steps max for v1. Output format: explicit headers. Fences: three to five never lines. Missing info: ask one clarifying question instead of guessing.

Draft the skeleton at https://promptmake.net/custom-gpt-generator from your three-sentence seed. Replace placeholder company names and policies before preview.

Expand steps after the first successful preview, not before. Long instructions before testing hide which line caused a failure.

Step 3: Conversation starters

Conversation starters are clickable example first messages. They onboard busy teammates faster than instructions alone.

Starters checklist: three or four realistic examples, each tied to real inputs, each showing required paste format, no lorem ipsum.

Good starter: Paste a support ticket with customer message and agent draft. I need a customer-ready reply.

Good starter: Paste meeting notes. Return an exec brief with decisions, owners, and open questions.

Weak starter: Help me with work. That teaches nothing about required fields.

Update starters when the workflow adds a required field such as ticket id or product sku. Starters are living onboarding, not set-and-forget marketing copy.

Starters can mirror your top AIPRM bracket templates if your team used libraries before GPTs. Same shape, different host.

Starter count and order

Ship four starters when possible: happy path, messy input, missing required field, edge case your team hits monthly.

Order starters by frequency. Most common task first so new users click the right example without reading all four.

Align starters with instructions

Each starter should trigger the workflow steps in Instructions without extra secret context. If a starter needs a ticket id, say paste ticket id and message in the starter text.

Mismatch between starters and instructions confuses preview tests. Fix starters and instructions in the same editing pass.

Step 4: Knowledge files

Knowledge holds PDFs, docs, or text uploads the model can search during chats. Add knowledge when you would otherwise paste the same long doc weekly.

Knowledge checklist: focused files, clear filenames, callouts in Instructions, version or date in filename, no duplicate rules across many files.

Good knowledge: brand voice guide v2026-08.pdf, product tier comparison one pager, approved macro snippets.

Weak knowledge: twelve overlapping PDFs that repeat refund policy with different wording.

In Instructions, name files the GPT should prefer: For tone, use brand-voice-2026.pdf. For tier limits, use product-tiers.pdf.

Refresh knowledge when policy changes. Stale PDFs are a top source of wrong GPT answers after model updates.

PromptMake does not upload knowledge to OpenAI. You attach files in the builder knowledge section yourself.

Knowledge size and hygiene

Prefer several focused files over one giant dump. Retrieval works better when filenames signal purpose.

Remove outdated files from the builder when you upload replacements. Two versions of the same policy invite contradictions.

Do not put secrets in knowledge. API keys, customer lists, and unreleased pricing belong outside GPT uploads.

Step 5: Capabilities, preview, and share

Capabilities extend senses: web browsing, image input, code interpreter. Enable only what the job needs. Extra capabilities invite unrelated behavior and longer safety review.

Actions connect to external APIs when your workspace supports them. Document in Instructions when an action must run before the model claims live status.

Preview checklist: open a fresh chat with the GPT after each meaningful instructions edit. Old threads may keep earlier behavior.

Run four preview prompts: happy path with full inputs, messy input, missing required field, fence test such as asking for unauthorized refund approval.

Log preview results in a team doc: date, model name, pass or fail, notes. GPTs need regression tests like code.

Sharing: align with admins on workspace GPT publish rules. Personal GPTs follow plan limits OpenAI documents at publish time.

Configure tab workflow

Use Configure for production edits you will diff against last week. Use Create chat for first exploration if your team prefers conversational drafting.

Work top to bottom: name, description, instructions, starters, knowledge, capabilities last.

After preview passes, copy final field text back to your internal repo or generator output doc so the next edit starts from truth.

When preview fails

If output format drifts, tighten Output format headers in Instructions before adding length.

If the model invents policy, add fences and missing-info lines. Add or refresh knowledge only after fences exist in Instructions.

If starters misfire, rewrite starters to include required paste fields explicitly.

Draft fields on PromptMake before the builder

Blank builder fields stall teams. https://promptmake.net/custom-gpt-generator turns your three-sentence seed into structured text: name, description, instructions blocks, starter suggestions.

Workflow: write seed offline, generate once, paste into Configure fields, replace placeholders, add knowledge files in builder, run four preview prompts, publish or share per admin rules.

Honest limits: PromptMake generates config text only. It does not create the GPT in ChatGPT, attach PDFs, toggle capabilities, or set workspace share permissions.

Guests get about three runs per day per path. Registered free users get about five. Use a run to beat blank-page delay, then edit every fence locally.

For Claude SKILL.md or Gemini Gem configs from the same job brief, use tabs on https://promptmake.net/skills. Host choice beats copying ChatGPT instructions into Claude verbatim.

Generator output to builder mapping

Map generator name to builder Name field. Map generator description to Description field. Map generator instructions section to Instructions field. Map starter list to Conversation starters.

Edit generated text until preview passes four tests. Do not publish generator output unedited.

Save winning field text in your team wiki with date and owner so the next policy change starts from a known good version.

Common mistakes when creating a Custom GPT

Mistake 1: Writing a novel in Instructions before the first preview test.

Mistake 2: Putting ticket-specific facts in Instructions instead of the user message.

Mistake 3: Duplicating conflicting rules across Instructions and five knowledge PDFs.

Mistake 4: Starters that do not match the workflow in Instructions.

Mistake 5: Enabling browsing or code tools the job does not need.

Mistake 6: Expecting PromptMake to publish the GPT because text was generated.

Mistake 7: Skipping preview on a fresh chat after an instructions edit.

Mistake 8: One GPT trying to cover support, sales, and legal with one instruction block.

Soft next steps

Pick one weekly ChatGPT chore today. Write the three-sentence seed. Generate fields at https://promptmake.net/custom-gpt-generator. Paste into Configure. Run four preview prompts. Share only after logs pass.

Read custom-gpt-explained for deeper field theory. Read what-is-a-custom-gpt if stakeholders need a product intro. This page stays on how to create a custom gpt with a checklist.

Quarterly: rerun four preview prompts, refresh knowledge filenames, update starters when the workflow adds required fields.

FAQ

How do I create a custom gpt step by step?

Confirm workspace create rights. Write a three-sentence job seed. Fill name and description in the GPT builder. Paste instructions with role, workflow, output headers, and fences. Add three or four conversation starters. Upload focused knowledge files if needed. Enable only required capabilities. Preview on a fresh chat with four test prompts before you share.

What fields are required to create a custom gpt?

Name and instructions are essential in practice. Description and conversation starters strongly affect adoption. Knowledge and capabilities are optional but common for reference-heavy jobs. Exact required fields follow OpenAI builder UI for your plan.

Can PromptMake create a custom gpt for me?

PromptMake https://promptmake.net/custom-gpt-generator drafts name, description, instructions, and starter text you copy into the ChatGPT builder. It does not publish GPTs in OpenAI or upload knowledge files. You complete builder steps and preview yourself.

How is this different from what-is-a-custom-gpt?

What-is-a-custom-gpt explains what Custom GPTs are and when to build. This page is a paste-ready how-to checklist with field order, preview tests, and generator workflow.

What should go in Instructions versus knowledge?

Instructions hold durable rules, workflow, output format, and fences that must apply every chat. Knowledge holds long reference docs the model retrieves when needed. Ticket-specific facts belong in the live user message, not in either layer.

How many conversation starters should I add?

Ship three or four starters covering your most common input shapes. Include one edge case and one missing-field example when possible. Order by frequency so new users click the right example first.

Why did my Custom GPT fail preview after I edited Instructions?

Old chat threads may keep prior behavior. Open a fresh chat with the GPT after instructions change. If failure persists, tighten output headers and fences before adding length or more knowledge files.