How to Use GPT Builder: A Practical Walkthrough

Custom GPTs Promise No-Code Power—But Check Who Can Still Build One First

Custom GPTs deliver on the no-code promise: you describe the assistant you want in plain English, and GPT Builder assembles it without a single line of code. For bounded workflows like contract intake or campaign brief review, that's genuinely useful—especially as 78% of organizations now use AI in at least one business function, up from 55% the year before.

Before you invest time in a build, check whether you still can. New GPT creation is now limited to Business, Enterprise, and Edu workspace users with permission—personal Free, Plus, and Pro accounts can no longer create, edit, or publish GPTs, per OpenAI's current documentation.

The bigger caveat is the retirement clock. OpenAI now states it is planning to retire custom GPTs and recommends migrating workflows to Plugins, with a migration experience targeted for September 17, 2026 and Enterprise retirement targeted for December 11, 2026. If your workspace falls in that path, build with the successor tool in mind.

Why the walkthrough still matters:

• Every custom GPT follows the same three-part recipe—instructions, knowledge files, and capabilities or actions—and that pattern transfers directly to Plugins and agent skills.
• Knowledge files are capped at 20 per GPT, each up to 512 MB, in PDF, Text, CSV, HTML, or Excel formats.
• Iteration, not feature-stacking, is what fixes most problems: tightening instructions and adding examples resolves issues faster than adding tools.
• Security is documented, not hypothetical—anyone using your GPT can download its knowledge files, and Actions can transmit PII with no built-in guardrail.

That last point deserves weight. Palo Alto Networks researchers demonstrated that code interpreter environments can access uploaded files and that third-party API Actions can leak PII and receive hidden prompt injections. MIT Sloan's guidance is blunt: never include non-public or PII data in a GPT's knowledge base. Agent skills extend this same instructions-plus-knowledge-plus-capabilities pattern to coding and chat-app agents—and because published research finds roughly 26% of skills carry at least one vulnerability, SkillzBench is building a free directory and MCP connector that pin versions, scan for risk, and benchmark each skill's actual Lift. The waitlist is open.

The Three-Lever Recipe: Instructions, Knowledge, and Capabilities

Building a reliable AI agent starts with understanding the universal architecture that underpins every custom GPT. Whether you are creating a simple chatbot or a complex workflow, the structure remains consistent across credible sources. You need to master three distinct levers: persistent instructions, knowledge files, and optional capabilities.

OpenAI explicitly recommends separating rules from reference material to maintain clarity. Instructions define the behavior, including tone, workflow constraints, and fallback actions. In contrast, knowledge files serve as the factual foundation for the model. This separation prevents the system from confusing operational rules with static data.

The interface supports this workflow through a split-screen design. You can describe your needs in plain English in the Create panel while monitoring outputs in real-time within the Preview pane. For finer control, the Configure tab allows direct editing of specific fields. This setup enables you to build conversationally or tweak technical parameters directly, ensuring precision without code.

Knowledge files provide the specific context your agent needs to answer accurately. You can upload up to twenty files, each with a maximum size of 512 MB. The system supports common formats such as PDF, Text, CSV, HTML, and Excel. This flexibility allows you to feed in diverse data sources, from legal contracts to product manuals. However, remember that anyone using the GPT can download these files, so avoid uploading sensitive private data.

Capabilities, or actions, extend the agent’s reach beyond text generation. These optional tools connect the GPT to approved external systems or APIs. While powerful, setting up actions is often the most complex part of the process. Zapier’s hands-on testing notes that external integrations can require significant technical effort to configure correctly. A GPT can use either apps or actions, but not both simultaneously.

To optimize your agent’s performance, focus on iteration rather than feature addition. MIT Sloan identifies iterating with the system as the most critical step in the creation process. OpenAI’s official guidance suggests tightening instructions and adding examples before introducing new tools. This approach often resolves issues faster than adding more capabilities.

Key components of the GPT architecture:

• Instructions: Persistent rules defining tone, task scope, and workflow logic.
• Knowledge: Reference files (PDF, CSV, Excel) limited to 20 files per GPT.
• Capabilities: Optional actions connecting to external APIs or systems.
• Interface: Split-screen Create/Preview for conversational building and direct editing.

This three-lever recipe forms the backbone of effective agent design. By keeping rules in instructions and facts in knowledge files, you create a robust and maintainable system. As you build, consider how these components translate to broader agent skills. SkillzBench is developing a free directory and MCP connector to help verify and benchmark these skill packages, ensuring security and quality in an ecosystem where vulnerabilities are common.

Iterate Before You Add Features: The Step Most People Skip

Most GPTs fail not because the builder is broken, but because the creator adds features before they've actually fixed the behavior they wanted. MIT Sloan calls iterating with the system the most important part of creating a custom GPT, and OpenAI's own guidance is blunt: tighten instructions and add examples before you reach for another tool.

The workflow itself is straightforward. You start at chatgpt.com/create, describe what you want in the Create panel, and watch the Preview pane respond in real time. The split-screen layout is the entire point: you talk to the builder on the left and test the result on the right, refining in a tight loop until the GPT does what you actually meant.

When something goes wrong, resist the temptation to upload more files or wire up a new action. OpenAI's documentation is explicit that tightening instructions and adding examples often fixes issues faster than adding features. Most early failures come down to vague instructions, not missing capabilities.

Three prompting patterns consistently produce better behavior in the Preview pane:

• Positive, concrete instructions. "Do X" outperforms "don't do Y" — long prohibition lists dilute the signal and the model fixates on the forbidden term.
• Explicit step structure. Frame workflows as "When X happens → do Y," with clear delimiters between steps so the model doesn't blur them together.
• Confirmed outputs. Always sanity-check the Preview against your source material. Zapier's hands-on testing flagged that uploaded knowledge files aren't consistently referenced, so clear prompt instructions often matter more than the documents themselves.
• Hallucination guard. Treat every factual claim as suspect until verified. MIT Sloan warns that AI tools "sometimes produce outputs that are incorrect and biased," and recommends reviewing interaction transcripts as part of the iteration loop.

Once the Preview behavior is stable, move to the Configure tab for fine-grained control. This is where you edit the system instructions directly, adjust the conversation starters, and decide which capabilities to enable. Per OpenAI's best practice, keep rules, tone, and workflow guidance in the instructions field, and reserve knowledge files for reference material only — mixing the two is one of the most common reasons a GPT behaves inconsistently.

The same iteration-first discipline applies once you graduate beyond GPT Builder. Agent skills — the SKILL.md instruction packages that power Claude Code, Codex, Cursor, and other coding agents — follow the identical instructions-plus-knowledge-plus-capabilities pattern, and published research has found roughly a quarter of them carry at least one vulnerability. That's exactly the gap SkillzBench is building to close: a free directory and free MCP connector that pin every skill to a commit SHA, security-scan and quality-judge each one, and publish benchmark Lift scores so you can see what actually helps before you wire it into a workflow. Join the waitlist to get notified when it goes live.

Deploy Without Leaking: The Security Checks Before You Share Your GPT

Your GPT isn't private the moment you publish it — and the biggest leaks come from files you uploaded yourself. Before you hit share, a handful of security checks can mean the difference between a useful tool and an accidental data breach.

The most overlooked risk is the knowledge base. As MIT Sloan's guide warns plainly, anyone using your GPT will be able to download the files in its knowledge base. If you've uploaded internal docs, contracts, or anything containing personal information, you've effectively published it.

Code interpreter adds another exposure. Palo Alto Networks researchers demonstrated that the code interpreter environment can execute system-level commands and access uploaded files at /mnt/data — meaning anything in the sandbox is reachable, not hidden.

Third-party Actions carry the sharpest warning of all. The same research found that ChatGPT "currently has no mechanism to stop sending PII data" to API endpoints, and that third-party APIs can and will collect that data. Worse, an API response can return hidden prompt injections that alter your GPT's behavior without the user ever knowing.

Your pre-deployment checklist:

• Never upload non-public or PII data — treat every knowledge file as publicly downloadable.
• Opt out of training data use if your files contain anything sensitive, a precaution Zapier's hands-on testing recommends explicitly.
• Choose the narrowest publishing level that works: only me, anyone with a link, or fully public.
• Audit any Actions you've connected — assume the API can see whatever the conversation contains.

Publishing scope matters more than most builders realize. A link-only GPT can still spread far beyond your team once a URL leaves the building, so pick "only me" during testing and widen access deliberately, not by default.

Finally, bake governance in from day one. Lumenalta's analysis of enterprise GPT deployments argues that most value comes from tight context control, disciplined permissions, and clear handoffs — define your source boundaries, escalation rules, and ownership before launch, not after an incident.

This same discipline applies beyond GPT Builder. Agent skills — SKILL.md instruction packages for coding and chat-app agents — follow the same "instructions plus capabilities" pattern, but published research suggests roughly 26% of agent skills carry at least one vulnerability. That's exactly why SkillzBench is building a free directory with security scanning, version pinning, and benchmark data to help you verify skills before you trust them. Join the waitlist to be first in line when it launches.

Where GPTs Fit in the Bigger Agent Picture—And How to Go Further, Safely

When OpenAI launched GPTs in November 2023, it framed them as more than a feature — the announcement positioned them as a stepping stone toward agents, letting "anyone easily build their own GPT—no coding required." That framing turned out to be accurate, just not in the way many expected. The same three-part recipe you just used in GPT Builder — instructions, knowledge, capabilities — has become the backbone of the entire agent ecosystem.

Today, that pattern lives on in agent skills: SKILL.md instruction packages that extend coding agents like Claude Code, Codex, Cursor, and Gemini CLI, plus chat-app agents. A skill bundles the same things a GPT did — behavioral rules, reference material, and tool access — but in a portable format any agent can consume. If you learned to build a GPT, you already understand skills.

The timing matters, too. OpenAI's current documentation states the company plans to retire custom GPTs in favor of Plugins, with Enterprise retirement targeted for December 11, 2026 and a migration flow targeted for September 17, 2026. New GPT creation is also now restricted to Business, Enterprise, and Edu workspace users. The skills you built in this walkthrough transfer directly to whatever comes next.

But going further requires going carefully. The security concerns we covered earlier — downloadable knowledge files, PII leakage through Actions, prompt injection through third-party APIs, as documented by Palo Alto Networks research — don't disappear with skills. Published research found roughly 26% of skills carry at least one vulnerability, and nobody installing one today can easily tell which ones are risky.

That's the gap SkillzBench is being built to close. Currently in pre-launch, SkillzBench is a free, independent directory and MCP connector designed to help teams adopt skills without the blind spots:

• Discover — continuously crawl and dedupe skills from GitHub into one searchable directory
• Verify — pin every version to a commit SHA, then license-check, security-scan, and quality-judge it
• Benchmark — test every skill in a sandbox with the same model, with and without the skill, and publish the Lift in percentage points
• Equip — one free MCP server plus per-agent loadouts, so each agent sees only the skills and tools you choose
• Stay current — track upstream changes, re-scan, re-benchmark, and notify you when something shifts

Everything — the directory, the MCP connector, benchmarks, and alerts — is free, and money never touches scores. If you want to take the next step from GPTs to agent skills safely, join the waitlist or newsletter at skillzbench.com and get notified at launch. Skills, proven.