AI-powered products are the future. It's why we've built an entire Mini-MBA program to teach you how to do it. But for those who don’t have the time or resources to build something in-house, custom GPTs are a good low-fi solution.

We use them all the time to help us create more courses, faster, while keeping our existing content fresh and up-to-date. Here’s how we do it.

Need a reminder on accessing the custom GPT functionality? Here’s our quick guide.

4 steps to create a custom GPT

Drawing from our experiences (including some valuable failures), we've developed a lightweight process for creating custom GPTs that can be managed by a single person. It starts by prioritizing use cases based on two factors:

• The initiative has to be high (potential) ROI and drive key metrics
• We should be able to measure the impact and value quickly

Once you’ve checked both these boxes, you’re ready to get started.

Step 1: Establish the GPT’s scope

Kick off with a short, tactical meeting to gauge the GPT concept, its feasibility, and goal.

Questions to answer:

1. What process will this GPT augment? (e.g., it will turn our course scripts into breakdown videos)
2. What core strength of AI is this leveraging? (e.g., its ability to generate new content from existing resources)
3. What does success look like for this GPT? (e.g., the existing one hour video scripting process will shorten to 10 minutes of edit time)

During this meeting, I recommend working through an internal product requirements worksheet that outlines the key requirements, objectives, and internal users as well as all the functional needs of the GPT — aka what the product actually does to drive value.

What your workbook should cover:

1. The specific actions the GPT should be able to do and who will be using it (e.g., the team should be able to feed it a script and get a video breakdown back)
2. The outputs you’re expecting from the GPT (e.g., the video breakdown should be formatted in a table with each of the following columns)
3. The metrics you’re tracking (e.g., this should save us X hours a week, allowing us to get a course done Y days sooner)

During this stage, put just as much emphasis, if not more, on defining what the GPT won’t do. This is crucial in preventing scope creep.

Step 2: Craft the prompts to train your GPT

Once the workbook is complete, you’re ready to set up a focused working session to craft the prompts that will train the custom GPT on your use case. This is where you turn your requirements into a prompt that you can feed the custom GPT to establish a baseline for response quality.

Here’s the prompt template we use as a starting point for all our custom GPTs:

- Objective: You are [GPT Name], an [the GPTs role]. Your task is to [the GPTs objective].

- Context: [GPT Name] is designed to [intended result or benefit]. [Background on why the task needs to be done].

- Task Breakdown: STEP 1: You will [ask questions / review information]. STEP 2: You will [Browse with Bing / use DALLE / analyze documents] to [purpose of step 2]. STEP 3: [Additional steps as needed].

- Rules: Your response will [parameters for the formatting of the response such as length or style]. Never [list boundaries, constraints or limitations such as topics to avoid or outputs to prevent].

How to prompt effectively:

1. Focus your prompts on the objectives you identified (e.g., the output should be in table format)
2. Iterate on your prompts and feed the GPT additional knowledge as necessary to fine tune it
3. Play around with the GPT to see if there are any edge case scenarios you should consider

At this stage, avoid being overly critical of the output. Your goal should be to get it good enough to prove viability of the use case – then you can spruce it up.

You should also consider if an API integration could enhance the capabilities of your custom GPT. External APIs (mostly through Zapier) allow you to connect your custom GPT to Google Docs, Sheets, email, or nearly any other third-party service. For example, you can instruct the custom GPT to write a prospecting message and then send it through your email.

Step 3: Refine your rough prototype

Once you have your initial prototype in hand, it’s time to test thoroughly, refine, and iterate on the prompts.

Put the product through its paces:

1. Test edge cases (e.g., what kind of inputs give you a low quality response)
2. Experiment with different prompts to see if the output quality changes (e.g., take on the persona of different prompting proficiencies to make sure if gives you workable answers at every level)
3. Scrutinize the output to get the GPT closer to what you want (e.g., do you like the way it’s formatted? Has it adopted your brand voice? Etc.)

Throughout this process, iterate on the instructions you give the GPT to get to the best result possible while understanding that perfection is not the goal (and not really possible). There will be hiccups at some point so to make sure the GPT can handle it gracefully, and consider adding backup plans in the instructions (e.g., If you don’t have enough context to successfully create an output, ask 3 clarifying questions).

This is also a good time to refine your understanding of what’s possible. As you iterate, you’ll learn new things about the capabilities and limitations of the GPT.

Step 4: Deploy to ChatGPT

When you’re ready for the internal launch, you can deploy it to your ChatGPT for Teams account for everyone to use – this will add it to your own private store of custom GPTs. If you don’t have a Teams account, you can deploy the custom GPT to the public store and share the link with anyone.

I recommend using a few minutes during recurring team meetings to talk about GPTs you’ve recently launched, explain how to use them, and link to any documentation.

Ongoing: Maintain your custom GPT

The launch of the custom GPT isn’t the end of the road, it’s really just the beginning. These are not static tools – just like any product, they should evolve to remain relevant and effective. You’ll have to step into the shoes of the product manager and make sure it’s maintained over time.

Your ongoing maintenance checklist should include:

• Identifying areas for improvement (e.g. the addition of an extra column would make this more useful…)
• Suggesting new features (e.g. let’s have it turn this video breakdown into something we can also feed the teleprompter)
• Providing feedback on performance (e.g. I have to edit the same 5 things every time, let’s train it on my edits)

Case study: Section’s custom GPTs

Traditionally, building a course from scratch has taken 6-8 weeks of dedicated effort across teams. Now multiply that by the 3-5 courses always in development, and factor in the 60 existing courses that need regular updates (especially for AI content).

We’ve been able to augment our content creation process (lessons planning, outlining, script drafting and edits, table reads, breakdown scripts for video etc.) with these custom GPTs:

• Lesson Outline Development: This custom GPT takes our existing course decks and generates structured lesson outlines to be used in script development.
  
  
• Script Creation: This custom GPT produces first drafts of lesson scripts that our education team can refine and align with learning objectives.
  
  
• Content Review: This custom GPT builds an AI avatar based on a script via an integration with our avatar generation tool, HeyGen.

These custom GPTs have shaved 20 hours off the course creation process, allowing us to release new courses to our members more regularly and update existing courses to deliver value through fresh insights.