Build a Coding Project Generator GPT

Design a Custom GPT that generates structured coding project outlines.

Introduction

30 Second Summary

When you ask ChatGPT to generate something structured, you get a different format every time. One response has 3 steps, the next has 7, and time estimates appear only when the model feels like it.

In this project, you will build a Custom GPT called "Project Architect" that takes any coding learning goal and produces a structured, actionable project outline every single time.

What You'll Build

A Custom GPT that generates consistent coding project outlines from any topic, using a five-section system prompt architecture and a knowledge file with example templates.

By the end of this project, you'll have:

A configured Custom GPT with a name, description, and conversation starters that set up your tool's identity.
A production-quality system prompt using the five-section architecture (Role, Goal, Constraints, Output Format, Stop Rules) that controls your GPT's behavior.
A reusable knowledge file with example project templates that anchors your GPT's output consistency across any topic.
Secret Mission: adaptive difficulty that detects experience level and adjusts project complexity accordingly.

Are there any prerequisites?

You need a ChatGPT Plus subscription and prior experience creating Custom GPTs. This project focuses on prompt engineering craft, not basic GPT Builder navigation.

Create Your Custom GPT Shell

Every Custom GPT starts as an empty shell. You give it a name, tell it how to introduce itself, and decide which built-in capabilities it can access.

In this step, you'll create the shell for Project Architect: its name, description, example prompts, and capability toggles. The system prompt and knowledge file come in later steps.

In this step, get ready to:

Open the GPT Builder and navigate to the Configure tab.
Set up the GPT's identity fields (name, description, conversation starters).
Configure the GPT's capabilities.

Open the GPT Builder

The GPT Builder is where you configure everything about a Custom GPT. You need to get to the Configure tab, which gives you direct control over each field.

In ChatGPT, click GPTs in the left sidebar.
Click Create to start a new Custom GPT.
Switch to the Configure tab at the top of the GPT Builder.

Why the Configure tab?

The GPT Builder has two tabs: Create and Configure. The Create tab lets you describe what you want in natural language and ChatGPT drafts instructions for you. The Configure tab gives you direct access to every field. Since this project is about learning prompt engineering, you want full manual control.

Don't see GPTs in the sidebar?

Make sure you're signed in with a ChatGPT Plus account. The GPT Builder is only available to Plus and Enterprise users. If the sidebar is collapsed, click the hamburger menu icon in the top left to expand it.

help me find the GPT Builder in my ChatGPT sidebar

Fill in the identity fields

The identity fields tell users what your GPT does before they even start a conversation. A clear name and description help you find it later, and conversation starters give users example prompts to click.

In the Name field, type Project Architect.
In the Description field, type:

Takes a coding learning goal and generates a structured, step-by-step project outline with tools, time estimate, and stretch challenge.

Scroll down to Conversation starters. Add each of the following as a separate starter:

I want to learn React hooks
Teach me how to build a REST API
I want to understand recursion
Help me learn Docker

What are conversation starters?

Conversation starters are clickable example prompts that appear when someone opens your GPT. They show users what kinds of inputs your GPT expects. Picking diverse coding topics (frontend, backend, algorithms, DevOps) signals that the GPT handles a wide range of learning goals.

Set capabilities

Capabilities are built-in tools your GPT can use. You only want the ones that serve your GPT's purpose.

Scroll down to the Capabilities section.
Enable Web Search (toggle it on if it is off).
Disable Image Generation (toggle it off).
Disable Code Interpreter (toggle it off). This may also be labeled Code Interpreter / Data Analysis depending on your interface.

Why enable Web Search?

Your GPT generates project outlines that recommend specific tools and versions. Web Search lets it look up current information so it suggests tools that actually exist and versions that are up to date.

Image Generation and Code Interpreter add nothing for a text-only project outline generator. Disabling them keeps the GPT focused and avoids unexpected behavior.

Do NOT click Update yet. You'll save the GPT after adding the system prompt in the next step.

Not sure which toggles are on or off?

Each capability has a toggle switch next to it. A filled or colored toggle means it's enabled. A grey or empty toggle means it's disabled. After configuring, only Web Search should show as enabled.

help me identify which capabilities are enabled in my Custom GPT Configure tab

Your GPT shell is ready. Next up, you'll write the five-section system prompt that controls how Project Architect behaves and what it outputs.

Write the Five-Section System Prompt

Your Custom GPT has a name and a face, but no brain yet. The Instructions field is where you give it one.

A system prompt tells the GPT who it is, what it produces, and what it refuses to do. You will write yours using a five-section architecture that separates identity, output shape, and guardrails into distinct Markdown sections the model can parse cleanly.

In this step, get ready to:

Write the Role, Goal, and Constraints sections that define identity and boundaries.
Write the Output Format section with a literal template the GPT must follow.
Write the Stop Rules section that handles out-of-scope requests.

Write the Role, Goal, and Constraints sections

The first three sections establish who the GPT is, what it produces, and what it must never do. Together they form a tight identity that prevents the model from drifting into generic chatbot behavior.

Click into the Instructions field on the Configure tab.
Paste the following text into the field:

## Role

You are Project Architect, a coding project designer. You take a learning goal and produce a structured, buildable project outline that teaches the target skill through hands-on practice. You are opinionated about tools and approaches. You pick specific technologies rather than leaving choices open.

## Goal

When a user shares a coding topic they want to learn, generate a single project outline that:
- Can be completed in under 60 minutes
- Teaches the target concept through building something tangible
- Uses specific, named tools (never "any editor" or "your preferred framework")
- Includes a stretch challenge for learners who want more

## Constraints

- NEVER generate full tutorials, code walkthroughs, or explain concepts at length. You produce project outlines only.
- NEVER suggest more than 5 steps in a project.
- NEVER leave tool choices open. Pick one and name it.
- ALWAYS include a time estimate for each step.
- ALWAYS include a stretch challenge at the end.
- If the user asks about a non-coding topic, politely explain that you design coding projects only and suggest they rephrase as a coding challenge.
- If the user gives a vague single-word input (e.g., "Python"), ask one clarifying question about what specifically they want to build or learn before generating.
- Reference the uploaded example-projects.md file to match the format and depth of the examples provided.

What do these three sections do?

The ## Role section gives the GPT a specific persona. Saying "opinionated about tools" prevents wishy-washy responses like "use any framework you prefer."

The ## Goal section defines the output conditions (under 60 minutes, tangible, specific tools, stretch challenge). This is the success criteria for every response.

The ## Constraints section uses NEVER/ALWAYS caps to set hard boundaries the model is less likely to ignore. The last bullet references a knowledge file you will upload in the next step.

Scroll through the Instructions field. You should see three ## headings: Role, Goal, and Constraints.

Text looks like plain text instead of headings?

The Instructions field does not render Markdown visually. You will see the raw ## characters in the field. That is correct. The model reads the Markdown structure even though the editor does not preview it.

If you accidentally pasted into the Description or Name field instead, clear it and paste into the large Instructions text area.

help me figure out why my Instructions field content looks wrong

Write the Output Format section

This is the most important section for consistency. By including a literal template inside the instructions, you give the model an exact skeleton to fill in for every response.

Place your cursor at the end of the Constraints section in the Instructions field.
Add a blank line, then paste the following below:

## Output Format

Every response MUST follow this exact structure:

```
# [Project Title]

**Difficulty:** [Easy / Medium / Hard]
**Estimated Time:** [X minutes]
**Tools:** [Specific tool list]

## What You'll Build
[2-3 sentence description of the finished product]

## Steps
1. **[Step Title]** (~X min) - [What the learner does in this step]
2. **[Step Title]** (~X min) - [What the learner does in this step]
3. **[Step Title]** (~X min) - [What the learner does in this step]

## Stretch Challenge
[A single harder extension that adds ~15 min]

## End State
[One sentence: what the learner has and what skill it proves]
```

Why use a fenced code block inside the instructions?

The triple backticks (```) tell the model "this is a literal template, not prose to interpret." Without them, the model might rearrange sections or merge headings.

The template shows 3 numbered steps, but the Constraints section allows up to 5. The model uses the template as a minimum structure and extends it when the topic needs more steps.

Scroll down in the Instructions field. You should see the ## Output Format heading followed by a fenced code block containing the template skeleton.

Backticks disappeared or the template looks broken?

Make sure you have exactly three backticks on a line by themselves before and after the template. If you accidentally deleted one, the model will not recognize the block boundary.

Double check that the ## Output Format heading sits above the fenced block, not inside it.

help me fix the Output Format section in my system prompt

Write the Stop Rules section

Stop Rules define what happens when a user asks something outside scope. Without them, the GPT will try to be helpful by writing code, explaining concepts, or generating multiple projects at once.

Place your cursor at the end of the Output Format section (after the closing ```).
Add a blank line, then paste the following below:

## Stop Rules

- If the user asks you to write code, explain concepts, debug errors, or do anything other than generate a project outline, say: "I design projects, I don't build them! Here's what I can do: give me a topic and I'll create a structured project outline for you."
- If the user asks for multiple projects at once, generate only the first one and offer to generate the next after they finish.
- If the input is ambiguous, ask exactly one clarifying question before generating.

What do these Stop Rules handle?

The first rule catches scope creep. Users will ask the GPT to write the actual code for a project. The canned response redirects them back to outline generation.
The second rule prevents the model from generating a wall of five projects in one message. It forces a one-at-a-time cadence.
The third rule handles vague inputs like a single word ("Python") by asking one clarifying question instead of guessing.

Scroll to the bottom of the Instructions field. You should see ## Stop Rules as the last heading, with three bullet points below it.

Instructions field feels too long or cluttered?

Scroll from top to bottom and count five ## headings: Role, Goal, Constraints, Output Format, Stop Rules. If you see fewer, one section may have been accidentally deleted or pasted inside another.

The total length should be around 400-600 words. If it feels significantly shorter, check that the Constraints bullets and the Output Format template are both present.

help me review my full system prompt for completeness

Why five sections instead of one big paragraph?

Markdown headings create visual boundaries the model uses to separate behavioral rules from output structure. A single block of prose makes it harder for the model to distinguish identity from format from guardrails.

Keeping the total prompt under 600 words also avoids the "lost-in-the-middle" problem where models pay less attention to instructions buried in long text.

✔️ Awesome, I've got everything!

Great. Double check you have five ## headings visible in the Instructions field, then move on.

ⓧ I'd like to double check the full prompt

Here is the complete system prompt. Your Instructions field should match this exactly:

## Role

You are Project Architect, a coding project designer. You take a learning goal and produce a structured, buildable project outline that teaches the target skill through hands-on practice. You are opinionated about tools and approaches. You pick specific technologies rather than leaving choices open.

## Goal

When a user shares a coding topic they want to learn, generate a single project outline that:
- Can be completed in under 60 minutes
- Teaches the target concept through building something tangible
- Uses specific, named tools (never "any editor" or "your preferred framework")
- Includes a stretch challenge for learners who want more

## Constraints

- NEVER generate full tutorials, code walkthroughs, or explain concepts at length. You produce project outlines only.
- NEVER suggest more than 5 steps in a project.
- NEVER leave tool choices open. Pick one and name it.
- ALWAYS include a time estimate for each step.
- ALWAYS include a stretch challenge at the end.
- If the user asks about a non-coding topic, politely explain that you design coding projects only and suggest they rephrase as a coding challenge.
- If the user gives a vague single-word input (e.g., "Python"), ask one clarifying question about what specifically they want to build or learn before generating.
- Reference the uploaded example-projects.md file to match the format and depth of the examples provided.

## Output Format

Every response MUST follow this exact structure:

```
# [Project Title]

**Difficulty:** [Easy / Medium / Hard]
**Estimated Time:** [X minutes]
**Tools:** [Specific tool list]

## What You'll Build
[2-3 sentence description of the finished product]

## Steps
1. **[Step Title]** (~X min) - [What the learner does in this step]
2. **[Step Title]** (~X min) - [What the learner does in this step]
3. **[Step Title]** (~X min) - [What the learner does in this step]

## Stretch Challenge
[A single harder extension that adds ~15 min]

## End State
[One sentence: what the learner has and what skill it proves]
```

## Stop Rules

- If the user asks you to write code, explain concepts, debug errors, or do anything other than generate a project outline, say: "I design projects, I don't build them! Here's what I can do: give me a topic and I'll create a structured project outline for you."
- If the user asks for multiple projects at once, generate only the first one and offer to generate the next after they finish.
- If the input is ambiguous, ask exactly one clarifying question before generating.

Your system prompt is complete. Next, you will create a knowledge file with example project outlines that anchor the GPT's output quality and upload it alongside these instructions.

Create and Upload the Knowledge File

Your system prompt tells the GPT what to produce, but it has no examples of what "good" actually looks like. Without reference material, the GPT will drift in tone, depth, and structure across different topics.

A knowledge file solves this. It gives the GPT concrete examples to calibrate against, anchoring every response to a proven template. In this step, you'll create a Markdown file with three diverse example project outlines and upload it to your GPT.

In this step, get ready to:

Create a knowledge file with 3 example project outlines covering different domains.
Upload the file to your Custom GPT and save your changes.

Create the example-projects.md file

The knowledge file contains complete example outputs that demonstrate the exact format, depth, and style you want the GPT to follow. Choosing diverse topics (web development, CLI tools, data processing) ensures the GPT sees the template applied across different domains.

Open any text editor on your computer (TextEdit on macOS, Notepad on Windows, or VS Code).
Create a new file and paste in the following content:

# Example Project Outlines

These examples demonstrate the format and depth that every project outline should follow.

---

# Build a Weather Dashboard with Fetch API

**Difficulty:** Easy
**Estimated Time:** 40 minutes
**Tools:** VS Code, Chrome DevTools, OpenWeatherMap API (free tier)

## What You'll Build
A single-page web app that fetches real-time weather data for any city and displays temperature, conditions, and a 5-day forecast. Styled with vanilla CSS.

## Steps
1. **Set Up the Project** (~5 min) - Create an index.html, style.css, and app.js file. Get a free API key from OpenWeatherMap.
2. **Build the Search UI** (~10 min) - Create an input field and button. Add an event listener that captures the city name on submit.
3. **Fetch and Display Current Weather** (~15 min) - Use the Fetch API to call OpenWeatherMap's current weather endpoint. Parse the JSON response and render temperature, humidity, and conditions to the DOM.
4. **Add the 5-Day Forecast** (~10 min) - Make a second fetch call to the forecast endpoint. Render the next 5 days as cards below the current weather.

## Stretch Challenge
Add localStorage caching so the last searched city loads automatically on page refresh, and add a loading spinner during fetch requests.

## End State
A working weather dashboard that proves you can fetch external API data, parse JSON, and render dynamic content to the DOM.

---

# Build a CLI Task Tracker with Node.js

**Difficulty:** Medium
**Estimated Time:** 50 minutes
**Tools:** VS Code, Node.js (v20+), terminal

## What You'll Build
A command-line application that lets you add, list, complete, and delete tasks. Data persists in a local JSON file between sessions.

## Steps
1. **Initialize the Project** (~5 min) - Run npm init, create index.js, and set up the file structure. Add a tasks.json file for persistence.
2. **Build the Add and List Commands** (~15 min) - Parse command-line arguments with process.argv. Implement "add" to append a task object to tasks.json and "list" to read and display all tasks with their status.
3. **Add Complete and Delete Commands** (~15 min) - Implement "done" to mark a task as completed by ID, and "delete" to remove a task. Handle edge cases like invalid IDs.
4. **Add Formatting and Help** (~10 min) - Color-code completed vs pending tasks using ANSI escape codes. Add a "help" command that prints available commands and usage.

## Stretch Challenge
Add due dates to tasks and a "overdue" command that filters and displays tasks past their deadline, sorted by urgency.

## End State
A functional CLI tool that proves you can build persistent command-line applications with file I/O and argument parsing in Node.js.

---

# Build a Markdown Blog Generator with Python

**Difficulty:** Medium
**Estimated Time:** 45 minutes
**Tools:** VS Code, Python 3.12+, terminal

## What You'll Build
A Python script that takes a folder of Markdown files, converts them to HTML, wraps them in a template, and outputs a static blog with an index page listing all posts.

## Steps
1. **Set Up the Project** (~5 min) - Create the project folder with content/, templates/, and output/ directories. Install the markdown library with pip install markdown.
2. **Parse Markdown Files** (~10 min) - Write a function that reads all .md files from content/, extracts the title from the first H1 heading, and converts the body to HTML using the markdown library.
3. **Apply the HTML Template** (~15 min) - Create a base.html template with placeholders for title and content. Write a function that injects each post's HTML into the template and saves it to output/.
4. **Generate the Index Page** (~10 min) - Build an index.html that lists all posts with titles and links. Sort posts alphabetically. Write the index to output/.

## Stretch Challenge
Add front matter parsing (date, tags) using a --- delimiter at the top of each Markdown file, and group posts by tag on the index page.

## End State
A working static site generator that proves you can automate file processing, template rendering, and batch HTML generation with Python.

What does this file do?

Each example follows the exact output template from your system prompt (Title, Difficulty, Estimated Time, Tools, What You'll Build, Steps, Stretch Challenge, End State). This gives the GPT concrete proof of what your format looks like when filled in.

The three examples span web development, CLI tools, and Python scripting. This diversity teaches the GPT that the template works regardless of the coding domain.

Save the file as example-projects.md somewhere easy to find (like your Desktop).

Save as plain text

If you're using TextEdit on macOS, go to Format > Make Plain Text before saving. Rich text formatting can corrupt the file for the GPT.

Upload the knowledge file and save your GPT

Now that the file is ready, you'll upload it to the GPT's Knowledge section. Your Instructions already reference this file from the Constraints section you wrote in the previous step.

In the Configure tab, scroll down to the Knowledge section.
Click Upload files.
Select the example-projects.md file you just saved.

Why Markdown for knowledge files?

Markdown files with clear headings work best for GPT retrieval. The structured formatting helps the model find and reference specific sections, unlike a flat PDF or unstructured text dump.

Scroll up to the Instructions field and confirm this line is present in your Constraints section:

- Reference the uploaded example-projects.md file to match the format and depth of the examples provided.

Click Update in the top right to save all changes.

Don't see the Update button?

The Update button sits in the top right corner of the GPT Builder. It can be easy to miss. If you don't see it, try scrolling to the top of the page.

If the upload failed, check that your file is saved with the .md extension and is under 512MB.

Help me troubleshoot my knowledge file upload.

You should now see example-projects.md listed under the Knowledge section, and your Instructions should contain the reference line pointing to it.

✔️ Awesome, I've got everything!

Great. Double check that you clicked Update to save your changes before moving on.

ⓧ I'd like to double check the full file

Here's the complete example-projects.md file for comparison:

# Example Project Outlines

These examples demonstrate the format and depth that every project outline should follow.

---

# Build a Weather Dashboard with Fetch API

**Difficulty:** Easy
**Estimated Time:** 40 minutes
**Tools:** VS Code, Chrome DevTools, OpenWeatherMap API (free tier)

## What You'll Build
A single-page web app that fetches real-time weather data for any city and displays temperature, conditions, and a 5-day forecast. Styled with vanilla CSS.

## Steps
1. **Set Up the Project** (~5 min) - Create an index.html, style.css, and app.js file. Get a free API key from OpenWeatherMap.
2. **Build the Search UI** (~10 min) - Create an input field and button. Add an event listener that captures the city name on submit.
3. **Fetch and Display Current Weather** (~15 min) - Use the Fetch API to call OpenWeatherMap's current weather endpoint. Parse the JSON response and render temperature, humidity, and conditions to the DOM.
4. **Add the 5-Day Forecast** (~10 min) - Make a second fetch call to the forecast endpoint. Render the next 5 days as cards below the current weather.

## Stretch Challenge
Add localStorage caching so the last searched city loads automatically on page refresh, and add a loading spinner during fetch requests.

## End State
A working weather dashboard that proves you can fetch external API data, parse JSON, and render dynamic content to the DOM.

---

# Build a CLI Task Tracker with Node.js

**Difficulty:** Medium
**Estimated Time:** 50 minutes
**Tools:** VS Code, Node.js (v20+), terminal

## What You'll Build
A command-line application that lets you add, list, complete, and delete tasks. Data persists in a local JSON file between sessions.

## Steps
1. **Initialize the Project** (~5 min) - Run npm init, create index.js, and set up the file structure. Add a tasks.json file for persistence.
2. **Build the Add and List Commands** (~15 min) - Parse command-line arguments with process.argv. Implement "add" to append a task object to tasks.json and "list" to read and display all tasks with their status.
3. **Add Complete and Delete Commands** (~15 min) - Implement "done" to mark a task as completed by ID, and "delete" to remove a task. Handle edge cases like invalid IDs.
4. **Add Formatting and Help** (~10 min) - Color-code completed vs pending tasks using ANSI escape codes. Add a "help" command that prints available commands and usage.

## Stretch Challenge
Add due dates to tasks and a "overdue" command that filters and displays tasks past their deadline, sorted by urgency.

## End State
A functional CLI tool that proves you can build persistent command-line applications with file I/O and argument parsing in Node.js.

---

# Build a Markdown Blog Generator with Python

**Difficulty:** Medium
**Estimated Time:** 45 minutes
**Tools:** VS Code, Python 3.12+, terminal

## What You'll Build
A Python script that takes a folder of Markdown files, converts them to HTML, wraps them in a template, and outputs a static blog with an index page listing all posts.

## Steps
1. **Set Up the Project** (~5 min) - Create the project folder with content/, templates/, and output/ directories. Install the markdown library with pip install markdown.
2. **Parse Markdown Files** (~10 min) - Write a function that reads all .md files from content/, extracts the title from the first H1 heading, and converts the body to HTML using the markdown library.
3. **Apply the HTML Template** (~15 min) - Create a base.html template with placeholders for title and content. Write a function that injects each post's HTML into the template and saves it to output/.
4. **Generate the Index Page** (~10 min) - Build an index.html that lists all posts with titles and links. Sort posts alphabetically. Write the index to output/.

## Stretch Challenge
Add front matter parsing (date, tags) using a --- delimiter at the top of each Markdown file, and group posts by tag on the index page.

## End State
A working static site generator that proves you can automate file processing, template rendering, and batch HTML generation with Python.

Your GPT now has both the rules (system prompt) and the reference material (knowledge file) it needs to produce consistent output. Next up, you'll put it to the test with real prompts and fix any inconsistencies.

Test and Refine Your GPT

Your system prompt and knowledge file are in place. The GPT looks ready on paper. But the real test of any prompt engineering work is whether it holds up under diverse, unexpected inputs.

In this step, you will run your GPT through a battery of test prompts spanning different coding domains and edge cases. You will compare every output against your template, identify where the GPT drifts, and write targeted rules to close those gaps.

In this step, get ready to:

Run 5 diverse test prompts covering different coding topics and edge cases.
Identify and fix any output drift by adding specific rules to your Instructions.
Re-test failed prompts and confirm your GPT produces consistent, template-matching outputs.

Run 5 diverse test prompts

A single test prompt tells you nothing about consistency. You need to stress-test across different domains to find where your system prompt breaks down.

In the GPT Builder, switch to the Preview panel on the right side of the screen.
Type the following 5 prompts one at a time, reviewing each output before sending the next.

Here are the 5 prompts to test, each targeting a different domain:

Frontend: I want to learn React hooks
Backend: Teach me how to build a REST API
DevOps: I want to learn Docker
Algorithms: I want to understand recursion
Off-topic: How do I train for a marathon?

For each output, compare it against your Output Format template. Check that every section is present: Project Title, Difficulty, Estimated Time, Tools, What You'll Build, Steps (with time estimates), Stretch Challenge, and End State.

What should I see?

The first four prompts should each produce a project outline that follows your template exactly. The off-topic prompt should trigger a polite redirect explaining that Project Architect designs coding projects only.

If any coding prompt produces output missing a section (no Stretch Challenge, no time estimates on steps, more than 5 steps), note which rule was violated. You will fix these in the next substep.

Keep a simple checklist

Open a text file or note and list each prompt with a pass/fail status. Write down the specific section that drifted for any failures. This makes the fix step much faster.

Identify and fix output drift

When a Custom GPT drifts from your defined template, the fix is always the same pattern: identify the specific failure, then add a targeted rule to the Constraints section that addresses it directly.

Return to the Configure tab in the GPT Builder.
Click into the Instructions field and scroll to the ## Constraints section.
For each output that failed your checklist, add a new rule targeting that exact failure.

What does a good fix look like?

Good rules are specific and actionable. They name the exact behavior to enforce or prevent.

For example, if a test output had 7 steps, the fix is: NEVER suggest more than 5 steps in a project. If a test output was missing time estimates, the fix is: ALWAYS include a time estimate for each step.

Avoid vague rules like "follow the format" or "be consistent." The more precise the rule, the more reliably the GPT follows it.

After adding your fixes, click Update in the top right to save your changes.

Why iterative refinement works better than writing everything upfront

You cannot predict every way a GPT will drift just by imagining inputs. Testing reveals the actual failure modes for your specific prompt. Each rule you add is a response to a real observed problem, which makes it far more effective than speculative guardrails.

This is iterative prompt refinement in action. Professional prompt engineers use the same cycle: test, observe, patch, re-test.

Re-test and confirm your fixes hold

Rules that look correct in writing can still fail in practice. You need to verify each fix actually changes the GPT's behavior.

Switch back to the Preview panel.
Re-run only the prompts that produced drifted output earlier.
Compare each output against your template checklist again. Every section should now be present and correctly formatted.

Still seeing drift after your fix?

If the same section is still missing or wrong, your rule may be too general. Try making it more specific. Instead of "include all sections," write "ALWAYS include a Stretch Challenge section with a single extension idea that adds approximately 15 minutes."

Also check that you clicked Update after editing. Changes are not applied until you save.

If you are stuck, help me figure out why my Custom GPT is still ignoring my formatting rules.

If any prompt still fails, repeat the cycle: add a more specific rule, click Update, and re-test.
Also re-run the off-topic prompt (How do I train for a marathon?) and confirm the GPT responds with a polite redirect instead of generating a hallucinated project.
Once all 5 prompts produce correct outputs, click Update one final time to save your refined GPT.

You should now have a GPT that reliably produces structured project outlines for any coding topic and gracefully handles off-topic input.

What does the polite redirect look like?

For off-topic input, your GPT should respond with something like: "I design projects, I don't build them! Here's what I can do: give me a topic and I'll create a structured project outline for you." The exact wording may vary, but it should clearly explain what the GPT can help with instead.

Secret mission

Add Adaptive Difficulty

Your GPT generates great outlines, but it treats a total beginner and a senior developer the same way. In this extension, you'll add conditional logic so the GPT detects or asks for experience level and adjusts project complexity accordingly.

Clean Up Your Resources

This project runs entirely within your existing ChatGPT Plus subscription, so there are no ongoing costs. Decide whether to keep your Custom GPT available, pause by leaving it alone, or delete it entirely.

Resources you used:

Custom GPT "Project Architect" (hosted in your ChatGPT account).
Local file example-projects.md (on your computer).

Keep everything running

No action needed. Choose this if you plan to keep using Project Architect to generate coding project outlines. Your Custom GPT stays accessible from the ChatGPT sidebar whenever you need it.

Pause - I'll come back to this later

No action needed here either. Your Custom GPT and knowledge file stay saved in your ChatGPT account indefinitely. There are no running processes or costs to pause.

When you return, open ChatGPT and find Project Architect in your GPTs list to pick up where you left off.

Delete - I don't want to use this again

Remove all project resources to start fresh.

Delete the Custom GPT: In ChatGPT, open your list of GPTs (click Explore GPTs in the sidebar, then navigate to your created GPTs). Select Project Architect, open its settings, and look for the delete option to remove it permanently.
Delete the local knowledge file: Find example-projects.md on your computer and move it to the Trash (macOS) or Recycle Bin (Windows), then empty it.
Delete test conversations: In ChatGPT, find any conversations you had with Project Architect in the sidebar. Hover over each one and delete them individually to clean up your chat history.

Nice Work!

You just built a personal AI tool that turns any coding topic into a structured, buildable project outline. That is prompt engineering in action.

You've learned how to:

Build a Custom GPT that generates structured coding project outlines from any learning topic.
Write a production-quality system prompt using the five-section architecture (Role, Goal, Constraints, Output Format, Stop Rules).
Create a knowledge file with example templates to anchor output consistency through few-shot prompting.
Secret Mission: Added adaptive difficulty that adjusts project complexity based on experience level.

Ready to quiz yourself?