# Custom Gpt

> Build a complete Custom GPT package from $ARGUMENTS (transcripts, raw text, or file paths).

- Skill: `tylerprogramming/custom-gpt` (Agent Skill)
- Install (CLI): `npx skillmds@latest add tylerprogramming/custom-gpt`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tylerprogramming/custom-gpt/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tylerprogramming (https://skillmd.com/u/tylerprogramming)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tylerprogramming/custom-gpt

---


Build a complete Custom GPT package from $ARGUMENTS (transcripts, raw text, or file paths).

## Overview

This skill produces everything needed to set up an OpenAI Custom GPT:
- `system-prompt.md` — Instructor personality, behavior rules, topic scope, response format
- `kb-*.md` — 2–4 knowledge base files, logically grouped, concise but complete
- `README.md` — Setup steps, sample test questions, video/topic coverage map

**Output location:** `~/content/custom-gpts/<project>/<gpt-slug>/`

---

## Step 1: Gather Input

If transcripts or text were passed as `$ARGUMENTS` or pasted into the message, use them directly.

If a file path was provided, read the file(s).

If no content was provided yet, ask:
> "Please paste your transcripts or point me to a file path. You can paste multiple videos — just separate them with a header like `Video Title: [name]`."

---

## Step 2: Ask Clarifying Questions

Before generating anything, ask these questions **all at once** in a single message (don't drag it out):

1. **GPT name** — What should this GPT be called? (e.g., "Sales OS Assistant")
2. **Instructor** — Who teaches this content? Name, role, credentials.
3. **Module context** — Is this part of a larger course/platform? What are the other modules? (Helps define what's out of scope.)
4. **Voice profile** — Is there already a voice profile file for this instructor? If so, where? (If yes, it gets uploaded as a separate Knowledge file — no need to bake it into system-prompt.)
5. **Conciseness level** — How long is the content? Should KB files be detailed or highly condensed? (Default: condensed — extract frameworks and scripts, not transcripts.)

If any of these are obvious from the content or context, skip asking and state your assumption.

---

## Step 3: Analyze the Content

Read through all transcripts/text and extract:

### Instructor Voice
- Tone and energy (casual, formal, fired up, calm)
- Signature phrases and filler words
- Teaching method (example-first, framework-first, story-based)
- What they explicitly say NOT to do (common mistakes they call out)
- Credentials and real numbers they reference

### Topics & Scope
- Full list of topics covered, with the video/section each comes from
- What is explicitly outside scope (mentioned as belonging to another module)
- Key frameworks, named systems, and processes
- Word-for-word scripts, templates, or formulas worth preserving verbatim

### KB Groupings
Identify 2–4 logical groupings for the knowledge base files. Good grouping criteria:
- By phase (e.g., strategy → execution → optimization)
- By topic cluster (e.g., ads + tracking vs. organic content)
- By video block (e.g., Videos 1–7 vs. Videos 8–14)

Aim for each KB file to be self-contained and focused.

---

## Step 4: Generate the Files

Create the output directory: `~/content/custom-gpts/<project>/<gpt-slug>/`

Where:
- `<project>` = the platform/course name in kebab-case (e.g., `kourse`)
- `<gpt-slug>` = the GPT name in kebab-case (e.g., `sales-os-gpt`)

If no project name is clear from context, use `custom-gpts` as the project folder.

---

### `system-prompt.md`

Structure:

```
# [GPT Name] — System Prompt

[1-2 sentence description of what this GPT is and who it serves]

## Your Instructor / Personality

[Instructor name, role, credentials]
[Tone descriptors — 4-6 bullet points]

### How You Talk
[Signature phrases, voice characteristics]

### How You DON'T Talk
[What to avoid — e.g., generic advice, pressure tactics, vague theory]

## How You Answer Questions

[4-5 numbered rules for answering — e.g., check KB first, be specific, give scripts not summaries]

## Topics You Can Help With

[Organized by category — mirror the KB structure. For each category, list 6-12 specific sub-topics as bullets. Be specific enough that the GPT knows what's covered.]

## Topics Outside Your Scope

[List other modules/sections and what topics belong there. Include a redirect template.]

## Response Format

[Formatting rules — length, use of bullets/bold/numbered lists, whether to end with action steps, etc.]
```

**Rules for system-prompt:**
- Instructor voice must be specific — generic "be helpful and friendly" is useless
- Topics list should be detailed enough that the GPT can self-identify whether a question is in scope
- Out-of-scope section prevents hallucination about topics not in the KB
- Do NOT include long scripts or frameworks here — those belong in KB files
- If a voice profile file exists (user confirmed in Step 2), skip voice details and add a note: "Voice and credentials are defined in the uploaded `voice-profile.md` knowledge file."

---

### `kb-*.md` (2–4 files)

Name files descriptively: `kb-<topic-group>.md`

Structure per file:

```
# Knowledge Base: [Topic Group Name]

## [Module/Course Name] — [Video or Section Range]

---

## [Section Title]

### [Sub-topic]

[Condensed, actionable content. Preserve:]
- Named frameworks with their components
- Word-for-word scripts (formatted in italics or blockquotes)
- Step-by-step processes (numbered)
- Key data points, thresholds, or rules of thumb
- Tables for multi-column information

[Do NOT preserve:]
- Filler, repetition, or motivational padding
- Long storytelling tangents (summarize the point they illustrate)
- Jokes or asides that don't add information
```

**Conciseness rules:**
- Extract the framework, not the explanation of the framework
- If a script is word-for-word, keep it word-for-word — that's the value
- If a concept takes 3 paragraphs to explain in the transcript, distill it to 3-5 sentences
- Tables > bullet lists > paragraphs (in that order of preference)
- Each KB file should be self-contained — someone reading just that file should understand the topic

---

### `README.md`

Structure:

```
# [GPT Name] — Setup Guide

## What's in This Folder

[Table: File | Purpose | Upload To]
[Include voice-profile.md row if applicable]

> Note: [Any important setup notes — e.g., "Do NOT upload X" or "Y's voice is in system-prompt directly"]

## Setup Steps (OpenAI Custom GPT)

1. Go to chat.openai.com → Explore GPTs → Create
2. In the Configure tab:
   - Name: [GPT Name]
   - Description: [1-sentence description]
   - Instructions: Copy/paste system-prompt.md
3. Under Knowledge, upload: [list all KB files + voice-profile if applicable]
4. Under Capabilities:
   - Disable Web Browsing
   - Code Interpreter: not needed
5. Save and test

## Sample Test Questions

[10-15 questions that cover the most important topics. For each, add → [what the correct answer should reference]]

## Knowledge Base Coverage Map

[Table: Video/Section | Topic | Knowledge File]
```

---

## Step 5: Review & Output

After generating all files, show the user:

1. A summary of what was created (file list + brief description of each)
2. The KB groupings chosen and why
3. The sample test questions (most useful for verifying coverage)

Ask: "Want me to adjust anything — the voice, add more topics, regroup KB files, or add more sample questions?"

If they're happy, confirm the output path and remind them:
- Paste `system-prompt.md` into the Instructions field
- Upload all `kb-*.md` files as Knowledge
- Upload `voice-profile.md` as Knowledge if applicable
- Disable web browsing

---

## Rules

- **Condense, don't transcribe.** KB files are not transcripts. They're distilled references.
- **Preserve scripts verbatim.** If the instructor gives a word-for-word script, keep it exactly.
- **Be specific in the system prompt.** Generic personality descriptions produce generic GPT behavior.
- **Group KB files by logical topic, not by video number** — unless the content is so large that video-number grouping is the only way to keep files manageable.
- **Never put long scripts or frameworks in system-prompt.** That's what KB files are for.
- **Out-of-scope = hallucination prevention.** Always include a clear out-of-scope section with redirect language.
- **Sample test questions should be hard enough to actually test coverage.** Not "what is X" but "walk me through how to do X" or "someone said Y — what do I do?"
- **If content is very large** (15+ videos, 50k+ words), create 3–4 KB files and be more aggressive about condensing. If content is small (3–5 short videos), one KB file may be enough.
- Save all files to `~/content/custom-gpts/<project>/<gpt-slug>/` — never anywhere else.

