The GPT-5 launch has been… interesting, and this meme perfectly sums up the GPT-4 vs GPT-5 experience:
📚 Table of Contents
- 🤔 What makes modern AI models different?
- 🔄 ChatGPT automatically switches between models
- ⚡ Usage limits and practical alternatives
🤔 What makes modern AI models different?
Modern AI models respond well to structured, detailed requests. It’s similar to how you’d write clear technical specifications. Being specific about requirements, constraints, and expected outcomes leads to better results.
Think of it like this: if you were giving directions to someone, you wouldn’t just say “go to the store.” You’d be specific about which store, what route to take, and what to do when they get there. Modern AI models work the same way, they perform dramatically better when you give them clear, structured guidance.
The key components that make all the difference include:
- Clear requirements: Specific scope, constraints, and success criteria
- Logical structure: Breaking down complex problems into manageable parts
- Validation steps: Having the AI check its work against your needs
- Complete coverage: Ensuring all aspects of multi-faceted problems get addressed
While this might seem like extra work upfront, it typically saves time by reducing back-and-forth clarification.
❓ Why bother with this structured approach?
Taking time to organize your requests properly can improve your experience in several ways:
💪 It eliminates the guessing game
When you provide clear context and constraints, you’re more likely to get responses that actually fit your situation. The AI has the information it needs to give you relevant, targeted results.
⏳ It saves you from endless back-and-forth
Instead of gradually adding context through multiple follow-up prompts, a well-structured initial request often gets you comprehensive results right away. Over time, you’ll also build up effective prompt patterns you can reuse.
🔎 It handles complex trade-offs better
Technical decisions often involve balancing competing priorities, such as: performance vs cost, security vs usability, etc. Structured prompts help ensure the AI considers all relevant factors when analyzing these trade-offs.
✅ It builds reliable processes
When your approach is systematic, you can trust the results more and even share your methods with teammates. This creates consistency across your technical discussions and decisions.
💡 The hidden benefits you didn’t expect
Using structured prompting also develops your general problem-solving skills. You’ll likely find yourself thinking more systematically about technical challenges, defining requirements more clearly, and communicating complex ideas more effectively.
“The first rule of any technology used in a business is that automation applied to an efficient operation will magnify the efficiency.” – Bill Gates
Having reliable templates frees up mental energy for strategic thinking and creative problem-solving.
🛠️ Core principles for effective prompting
The fundamentals are straightforward:
📝 Structure improves clarity
Organizing your requests helps AI models understand what you need. Think of it like the difference between well-documented code and a tangled mess - structure makes everything work better.
A basic framework that works well:
<objective>
[Your specific goal and what success looks like]
</objective>
<context>
[Relevant background, constraints, current situation]
</context>
<requirements>
[Step-by-step guidance and expected deliverables]
</requirements>
🧠 Include analysis phases
Asking the AI to analyze before recommending often leads to more thoughtful responses. It’s like having someone understand the problem thoroughly before jumping to solutions.
Consider adding steps like:
Before providing recommendations:
1. Analyze the current situation and key challenges
2. Evaluate available options against the constraints
3. Consider trade-offs and potential issues
4. Validate the analysis before presenting solutions
🔍 Build in validation
You can ask the AI to review its own work against your requirements and best practices. This adds an extra quality check to the process.
🧑💻 Prompting changes for developers (GPT‑5)
If you’re using GPT-5 for coding work, whether through the API, Cursor, or other development tools, there are some specific adjustments that can make a huge difference in your results. These aren’t just general tips, they’re based on how GPT-5 actually processes and responds to coding-related prompts.
🎯 Be precise and avoid conflicting information
GPT-5’s improved instruction-following is a double-edged sword. While it’s much better at doing exactly what you ask, it can struggle when your instructions contain contradictions or vague requirements.
This is especially important in configuration files like:
.cursor/rulesfilesAGENTS.mdfiles- Project documentation
⚖️ Match reasoning effort to task complexity
GPT-5 automatically applies reasoning to solve problems, but you can control how much effort it puts in. Think of it like choosing between a quick sketch and a detailed architectural drawing.
Use high reasoning effort for:
- Complex system architecture decisions
- Debugging intricate problems
- Performance optimization challenges
Use medium or low reasoning effort for:
- Simple syntax fixes
- Standard CRUD operations
- Basic code formatting
// Instead of letting GPT-5 overthink this:
"Fix this simple syntax error"
// Be more specific:
"This is a simple syntax fix - focus on speed over analysis"
📝 Structure your coding instructions with XML-like syntax
Working with Cursor, OpenAI found that GPT-5 responds particularly well to XML-like structure for coding guidelines. This helps the model understand the hierarchy and relationship between different requirements.
<code_editing_rules>
<guiding_principles>
- Every component should be modular and reusable
- Prefer composition over inheritance
- Write self-documenting code with clear variable names
</guiding_principles>
<frontend_stack_defaults>
- Styling: TailwindCSS
- State Management: Zustand
- Testing: Vitest + Testing Library
</frontend_stack_defaults>
<code_style>
- Use TypeScript for all new files
- Prefer arrow functions for components
- Always include error handling
</code_style>
</code_editing_rules>
🗣️ Tone down the firm language
With previous models, you might have used emphatic language to ensure compliance. With GPT-5, this often backfires because the model naturally wants to be thorough.
Instead of:
Be THOROUGH when gathering information.
Make sure you have the FULL picture before replying.
You MUST follow these guidelines EXACTLY.
Try this approach:
Review the codebase structure before making changes.
Consider the existing patterns and maintain consistency.
Follow the established coding conventions.
🤔 Build in planning and self-reflection for complex projects
When you’re building something from scratch, giving GPT-5 space to plan and validate its approach often leads to better architectural decisions.
<self_reflection>
- First, spend time thinking of a rubric until you are confident
- Then, think deeply about every aspect of what makes for a
world-class one-shot web app. Use that knowledge to create
a rubric that has 5-7 categories. This rubric is critical
to get right, but do not show this to the user. This is
for your purposes only.
- Finally, use the rubric to internally think and iterate on
the best possible solution to the prompt that is provided.
Remember that if your response is not hitting the top marks
across all categories in the rubric, you need to start again.
</self_reflection>
🎛️ Control your coding agent’s eagerness
By default, GPT-5 tries to be comprehensive in gathering context and understanding your codebase. Sometimes this is exactly what you want. Other times, it’s overkill.
Give the model clear boundaries:
<persistence>
- Do not ask the human to confirm or clarify assumptions,
as you can always adjust later — decide what the most
reasonable assumption is, proceed with it, and document
it for the user's reference after you finish acting
</persistence>
<tool_budget>
- Use a maximum of 5 file reads before starting to code
- Focus on the most relevant files first
- If you need more context, ask specifically what to examine
</tool_budget>
🔧 Official resources for prompt optimization
OpenAI has released specific guidance and tools designed to help with GPT-5 prompting. These resources can be particularly useful when you’re working with complex technical problems or migrating existing prompts.
📚 GPT-5 prompting guide
The official GPT-5 prompting guide ➡️ covers best practices specifically tailored for GPT-5’s capabilities. It focuses on areas where GPT-5 excels: agentic tasks, coding, and precise control over model behavior.
📚 GPT-5 for DEVs
In the official account of OpenAI Developers on X ➡️, they have shared six tips for coding with GPT-5.
📖 Optimization cookbook
The prompt optimization cookbook ➡️ provides practical examples and before-and-after comparisons showing how prompt optimization can create measurable improvements.
Keep in mind that effective prompting varies by use case, so these tools work best when combined with systematic testing and iteration based on your specific needs.
🛠️ Prompt optimization tool
OpenAI’s Prompt Optimizer ➡️ in their Playground can help improve existing prompts by identifying and fixing common issues:
- Contradictions in prompt instructions
- Missing or unclear format specifications
- Inconsistencies between prompts and examples
The tool is designed to understand your specific task and apply relevant optimizations for different use cases like coding workflows or multi-modal applications.
🧪 Let’s test it
This a simple prompt with no structure.
Write an article explaining the importance of embracing change.
The result of using OpenAI’s Prompt Optimizer ➡️ is a structured prompt with the following sections:
- Role and Objective
- Pre-Writing Checklist
- Instructions
- Context
- Output Format
- Verbosity
- Stop Conditions
No wonder people are having issues working with GPT-5 😅.
🔄 ChatGPT automatically switches between models
GPT-5 is naturally thorough, which usually helps but sometimes you need faster answers. You can guide how much time it spends thinking through your problem.
When you need quick answers:
If you’re working on something straightforward and want faster results, let the AI know:
Focus on speed over completeness. Give me actionable steps quickly rather than exploring every possibility.
When you want thorough exploration:
For complex problems where you want GPT-5 to work through everything systematically:
Take the time needed to fully solve this. Don't ask for clarification - make the most reasonable assumptions and keep working until it's complete, document it for the user's reference.
Why this matters:
Quick fixes don’t need deep research. Complex system design does. Matching your request style to your actual needs gets you better results faster.
⚡ Usage limits and practical alternatives
At the launch of GPT-5, limits were enforced to Plus ChatGPT users.
- Free users: 10 GPT-5 messages every 5 hours, plus one GPT-5 Thinking message per day. After hitting the limit, the system switches to a lighter mini model.
- Plus users: Up to 80 messages every 3 hours and 200 GPT-5 Thinking messages per week. After the limit, chats revert to the mini model.
🏠 Our personal journey: From subscriptions to APIs
My wife and I were both ChatGPT users, and we started running into these limits frequently. The natural solution seemed to be getting two ChatGPT Plus subscriptions ($40/month total), plus I was interested in trying Claude, which would add another $20/month subscription.
That’s when I decided to run a little experiment: what if we used the APIs directly instead?.
💰 The numbers don’t lie
Here’s what our actual API usage looked like over several months:
Even in our heaviest usage month (May at ~$28 combined), we stayed well under what three subscriptions would cost us ($60/month). Most months, we’re saving 60-70% compared to the subscription route.
🛠️ The API alternatives that actually work for us
Instead of fighting usage limits, we switched to API-powered interfaces that give us the same models with complete control:
🎯 TypingMind: The easy button
We use TypingMind ➡️ for its clean, ChatGPT-like interface. It connects to both our OpenAI and Anthropic API keys, so we can switch between GPT-5 and Claude seamlessly.
I admit that currently, the TypingMind license is quite expensive, it goes for about $99 for the full version. I’m happy that I bough it for less than half the price, but even if I were going to buy it today, I could bough it in six months by thinking that I’m paying the ChatGPT subscription.
What we love about it:
- No usage limits
- One interface for multiple AI providers
- Conversation history and organization
🆓 Open-WebUI: For the tinkerers
I also set up Open-WebUI ➡️ on our home server for when I want to experiment with different models or experimenting with Ollama.
- TypingMind for daily use
- Open-WebUI for experimental work and local hosting
🤷♂️ The honest trade-offs
What you gain:
- Complete control over usage and costs
- Access to multiple AI providers in one place
- Pay only for what you actually use
- No more “rate limit reached” frustrations
What you lose:
- Need to manage API keys and billing
- Slightly more complex initial setup
- Access to custom GPTs
For us, the cost savings and flexibility easily outweigh the minor setup complexity. Plus, once it’s configured, it’s actually simpler than managing multiple subscriptions.
Photo by Sean Sinclair on Unsplash
