Chapter 37 Exercises: Custom GPTs, Assistants, and Configured AI Systems

These exercises progress from understanding configured AI systems to building and deploying your own. Exercises 1-6 are primarily analytical and design-focused; Exercises 7-14 require hands-on building; Exercises 15-20 address deployment, maintenance, and advanced patterns.

Part A: Understanding Configured Systems

Exercise 1: Platform Comparison

Explore the three configured AI platforms covered in this chapter: Custom GPTs (if you have ChatGPT Plus or Team), Claude Projects (if you have Claude Pro or Team), and any publicly available Custom GPTs in the GPT store.

For each platform you have access to: 1. Spend 20 minutes exploring the configuration interface 2. Note what configuration options are available 3. Note what limitations or constraints you observe

Write a 300-word comparison of the platforms based on your exploration. Focus on: ease of configuration, customization depth, sharing capabilities, and appropriateness for your specific professional context.

Exercise 2: GPT Store Evaluation

Identify three Custom GPTs from the GPT store that are relevant to your professional domain.

For each GPT: 1. Test it with five representative queries relevant to your work 2. Evaluate: quality of responses, consistency across queries, scope awareness (does it stay in its lane?), and usefulness compared to a general AI assistant 3. Try to identify at least one limitation or failure mode

Write a comparative evaluation: which GPT would you actually use, and why?

Exercise 3: System Prompt Reverse Engineering

When you interact with a well-configured AI system, you can often infer the structure of its underlying system prompt from how it behaves.

Choose any Custom GPT from the store or any AI assistant you use regularly. 1. Interact with it across 10+ different types of queries 2. Try to infer: what is its persona? What are its behavioral constraints? What is it configured to do and not do? 3. Write your best guess at the structure (not verbatim text) of its system prompt

Then ask the AI directly: "Can you summarize what your instructions say about [topic you've identified]?" Compare what it reveals to your inference.

Exercise 4: Failure Mode Mapping

For each of the three types of configured systems (Custom GPT, Claude Project, API-based assistant), identify two distinct failure modes — ways the configured system could underperform or behave unexpectedly.

For each failure mode, describe: - What causes it - What the user experience of the failure looks like - How the system designer could prevent or mitigate it

Your answer should identify six distinct failure modes total.

Exercise 5: Knowledge Base Audit

Take any substantial document from your own work (a guidelines document, a process document, a research report, or a policies document) and audit it for effectiveness as a knowledge base file.

Evaluate it against the criteria from the chapter: - Does it use descriptive headers? - Are key facts stated directly at the start of sections? - Does it use consistent terminology? - Is it focused on a single topic, or mixed? - Are there sections that an AI would not need (general knowledge it already has)?

Write a 200-word audit and a brief action plan for reformatting it for better retrieval.

Exercise 6: Assistant Brief Writing Practice

Choose an AI tool you use regularly (any AI tool — it does not have to be a configured system). Write an assistant brief for it as if you were the person who configured and deployed it.

Your brief should cover all sections from the template in the chapter. If you do not know certain details (like the system prompt), document what you can infer from its behavior.

This exercise develops the habit of thinking explicitly about what a configured AI system does, what it does not do, and how to communicate that to users.

Part B: Building Your First Configured System

Exercise 7: Design Before Building

Before building anything, design a configured AI system for a recurring task in your professional work.

Your design document should include: 1. Purpose statement (one sentence) 2. Primary users (who will use this) 3. Five representative use cases with example inputs and expected outputs 4. System prompt outline (following the template in the chapter) 5. Knowledge base plan: what files will you include and why? 6. Testing plan: how will you evaluate whether it works? 7. Maintenance plan: how will you keep it current?

Spend at least 30 minutes on this design before moving to Exercise 8.

Exercise 8: Build a Custom GPT or Claude Project

Using your design from Exercise 7, build your configured system on the platform most appropriate for your use case (Custom GPT for sharing, Claude Project for personal use).

Requirements: - System prompt must be at least 400 words and cover all sections from the template - At least one knowledge file uploaded and verified to work - Conversation starters (for GPT) or initial context established (for Project) - At least five test interactions documented

Document each decision you made during the build that was different from your original design, and why.

Exercise 9: System Prompt Iteration

Take the system prompt from Exercise 8 and improve it through three iterations.

For each iteration: 1. Identify a specific failure mode or limitation from your testing 2. Write a hypothesis about what change to the system prompt would address it 3. Make the change 4. Test the specific failure case again 5. Document whether the change worked and what else changed

After three iterations, write a summary of what you learned about how small system prompt changes affect behavior.

Exercise 10: Knowledge Base Construction

Build a comprehensive knowledge base for the configured system from Exercise 8.

Requirements: - At least three distinct knowledge files covering different aspects of your domain - Each file reformatted for retrieval (descriptive headers, direct fact statements, consistent terminology) - At least one file that documents quality standards or examples of good work - Test each file by asking questions whose answers are in that file

Document: which files improved performance most and why? Were there files that did not seem to help?

Part C: Advanced Configuration

Exercise 11: Boundary and Escalation Design

Take the configured system from Exercise 8 and stress-test its boundary conditions.

Conduct a systematic adversarial testing protocol: 1. Ask questions clearly outside its scope — does it gracefully decline or does it attempt an answer? 2. Ask ambiguous questions that could be interpreted multiple ways — how does it handle ambiguity? 3. Ask for information it does not have — does it acknowledge the limit or fabricate? 4. Try to make it behave as a different AI or override its instructions — how does it respond?

Based on your testing, add or revise boundary and escalation instructions to handle the failure cases you found.

Exercise 12: Multi-System Workflow

Design a workflow that uses two or more configured systems in sequence — the output of one feeds the input of another.

Example: a Research GPT produces research summaries → a Writing GPT transforms them into polished drafts → a Brand Voice GPT reviews for consistency.

Build both systems and test the full workflow on a real task from your work. Document: where did the handoff between systems work well? Where did it break down?

Exercise 13: Build a Multi-Turn Chatbot with the Assistants API

Using the Assistants API code from the chapter, build a multi-turn domain-specific chatbot.

Choose a domain where you have genuine expertise (or access to a detailed knowledge document to upload). Create an assistant with: - A detailed system prompt (minimum 300 words) - At least one uploaded knowledge file with file_search enabled - A thread management interface that allows users to start new conversations or continue existing ones

Test with at least 15 interactions across two separate threads. Document the behavior differences between threads (which should be independent).

Exercise 14: The "Assistant Brief" for Your Built System

Write a complete assistant brief for the configured system you built in Exercises 8-10.

Requirements: - All sections from the template must be completed - The "Known Limitations" section must be based on actual testing, not speculation - The brief must be written so that a colleague who knows nothing about your build process could use and maintain the system - Include version number and date

Exchange briefs with a colleague (or a classmate, or someone from a professional community) and give each other feedback: what is unclear? What is missing? What would make this more useful?

Part D: Deployment, Maintenance, and Reflection

Exercise 15: User Testing Protocol

Have someone who was not involved in building your configured system use it for a real task without guidance from you.

Watch (or review the transcript) of their interaction. Note: - Where did they get confused or stuck? - What did they try that did not work as expected? - What expectations did they have that the system did not meet? - What did they like?

Based on your observation, make three specific improvements to the system and document the before/after comparison.

Exercise 16: Maintenance Simulation

Simulate a quarterly maintenance review for your configured system.

1. Review your system prompt: is any guidance outdated, incorrect, or missing?
2. Review your knowledge files: is any content outdated? Are there missing topics that users have asked about?
3. Review your test suite: are there new edge cases to add?
4. Document what you changed and why

This exercise builds the habit of treating configured AI systems as living products that require maintenance, not set-and-forget tools.

Exercise 17: Platform Limitations Exploration

Choose one platform (Custom GPT or Claude Projects) and systematically explore its limits.

1. What is the maximum system prompt length before performance degrades?
2. What types of knowledge files retrieve most reliably vs. least reliably?
3. How does the system handle requests that are adjacent to but outside its configured scope?
4. What happens when the knowledge base contradicts the system prompt?

Write a 400-word "platform notes" document documenting your findings. This is the kind of institutional knowledge that experienced practitioners build and beginners lack.

Exercise 18: Team Deployment Planning

Design a deployment plan for making one of your configured systems available to a team of five to ten colleagues.

Your plan must address: - How users will access the system - What onboarding or documentation you will provide - How you will collect feedback from users - What governance applies (who can modify the system?) - How you will handle it when the system produces a notably wrong or inappropriate response - What metrics you will track to know if the deployment is successful

This exercise previews Chapter 38's material on AI tool deployment for teams.

Exercise 19: Competitor Analysis — Configured AI Platforms

Research the current landscape of configured AI platforms beyond Custom GPTs and Claude Projects.

Identify at least two additional platforms or approaches (for example: Poe's Bot Builder, Coze, Botpress, Voiceflow, or custom API implementations). For each: - What configuration options does it offer? - What are its strengths compared to GPT Builder and Claude Projects? - What types of use cases is it best suited for? - What are its limitations?

Write a 500-word comparison. Given your specific professional use case, which platform would you choose for your primary configured system and why?

Exercise 20: Capstone — A Polished, Deployed Configured System

Build a fully polished configured AI system for a real, recurring professional use case.

Requirements: - Complete system prompt (minimum 500 words, all template sections completed) - Minimum three knowledge files, properly formatted for retrieval - Documented test protocol with results - Complete assistant brief - Deployment plan and at least one person other than you has used it - Post-deployment review: what worked, what did not, what you would change

This is your configured system portfolio piece. Build it with the level of care you would invest in any professional tool you expect colleagues to rely on.