Skip to main content

Custom Instructions Overview

Custom instructions let you configure default preferences that apply to all your conversations with AI. Think of them as persistent guidelines that shape how AI responds to you.
Custom instructions are applied to every message in every conversation, helping AI understand your preferences, context, and communication style without repeating yourself.

Why Use Custom Instructions?

Save Time

Avoid repeating the same context or preferences in every conversation

Consistent Responses

Get responses formatted and styled the way you prefer

Personalized AI

AI understands your background, role, and specific needs

Better Results

Provide context once, get relevant answers every time

Setting Custom Instructions

1

Open Settings

Click your profile avatar in the top-right corner, then select Settings.Keyboard shortcut: Cmd/Ctrl + ,
2

Navigate to Custom Instructions

In the settings sidebar, click Custom Instructions under the Chat section.
3

Fill in your preferences

You’ll see two main sections:
  • About You: Context about yourself
  • Response Preferences: How you want AI to respond
4

Save and apply

Click Save to apply your instructions to all future conversations.
Custom instructions take effect immediately for new messages.

About You Section

Tell AI about yourself to get more relevant, personalized responses.

What to Include

Your role and expertise:
  • Job title and industry
  • Areas of specialization
  • Years of experience
  • Technical skills
Example:
I'm a senior full-stack developer with 8 years of experience, 
specializing in React, Node.js, and cloud architecture (AWS). 
I work at a fintech startup building payment processing systems.
This helps AI calibrate technical depth and suggest appropriate solutions for your skill level.
What you’re working on:
  • Current projects
  • Learning goals
  • Technologies you’re exploring
  • Problems you’re solving
Example:
I'm currently building a mobile app with React Native and learning 
TypeScript. I'm also exploring microservices architecture and Kubernetes 
for our infrastructure migration.
How you work:
  • Preferred languages or frameworks
  • Tools you use
  • Constraints (team standards, legacy systems)
  • Platform requirements
Example:
My team uses Python 3.11, Django 4.2, and PostgreSQL. We follow PEP 8 
style guidelines and use type hints. All code must be compatible with 
our existing Django monolith.
Personal context:
  • Educational background
  • Hobbies related to your work
  • Side projects
  • Areas of interest
Example:
I have a CS degree and enjoy contributing to open-source projects. 
I'm interested in AI/ML applications, especially in natural language 
processing. I also enjoy technical writing and documentation.

Good “About You” Examples

I'm a frontend developer with 5 years of experience, specializing in 
React and Vue.js. I work on a large-scale e-commerce platform with 
complex state management needs. I prefer functional programming 
patterns and modern ES6+ JavaScript. I'm currently learning Next.js 
and exploring server-side rendering.

Response Preferences Section

Define how you want AI to format and structure responses.

Response Style

Set the tone:Professional:
Respond in a professional, business-appropriate tone. Use formal 
language suitable for work communications.
Casual:
Keep responses conversational and friendly. Use a casual tone like 
you're explaining to a colleague over coffee.
Educational:
Explain concepts clearly as if teaching. Use analogies and examples 
to illustrate complex topics. Be patient and thorough.

Output Format Preferences

How you want code presented:
For code examples:
- Always include complete, runnable code
- Add inline comments explaining key logic
- Use TypeScript for JavaScript examples
- Follow Airbnb style guide conventions
- Include error handling
- Show expected output or results
Response structure:
When answering questions:
1. Start with a brief direct answer
2. Provide detailed explanation
3. Include practical code examples
4. List edge cases and considerations
5. Suggest next steps or related topics

Use bullet points for lists and numbered steps for procedures.
For technical documentation:
When creating documentation:
- Use clear headings and sections
- Include code examples for each concept
- Add "Why" explanations, not just "How"
- Include common pitfalls and solutions
- Reference official documentation when relevant
Teaching style:
When explaining concepts:
- Start with the "why" before the "how"
- Use real-world analogies
- Show simple examples first, then complex ones
- Explain trade-offs between different approaches
- Point out common mistakes and how to avoid them

Good Response Preferences Examples

Keep code examples production-ready with error handling and TypeScript 
types. Be direct and concise - I value efficiency over lengthy explanations. 
When showing code, include only essential comments. If there are multiple 
approaches, briefly list pros/cons. I prefer functional programming patterns 
and modern syntax.

Advanced Custom Instructions

Using Variables

Reference your custom instructions within responses:
My role: [Specify what you do]
My goal: [What you're trying to achieve]
My constraints: [What limitations exist]
My preferences: [How you like things done]

Conditional Instructions

Set preferences for different scenarios:
For code reviews:
- Focus on security, performance, and maintainability
- Suggest specific refactoring improvements
- Point out potential bugs

For debugging help:
- Ask clarifying questions about the error
- Show step-by-step debugging approach
- Explain the root cause, not just the fix

For learning new concepts:
- Explain with simple examples first
- Build up to complex scenarios gradually
- Include exercises to practice

Domain-Specific Instructions

Tailor AI responses to your field:
For web development:
- Always consider mobile responsiveness
- Include accessibility (ARIA, semantic HTML)
- Show both JavaScript and TypeScript versions
- Consider performance and bundle size
- Suggest testing approaches
- Follow React best practices and hooks patterns

Tips for Effective Custom Instructions

Good balance:
  • Provide concrete details about your context
  • Avoid unnecessary verbosity
  • Focus on what actually affects responses
  • Update as your needs change
Too vague:
I'm a developer. Help me with code.
Just right:
I'm a Python backend developer working with Django and PostgreSQL. 
Show production-ready code with error handling. I prefer type hints 
and functional patterns.
Too lengthy:
I'm a developer and I've been programming for 10 years and I started 
with Java but now I use Python and sometimes JavaScript and I really 
like functional programming and I read this book about clean code and 
I try to follow those principles and I work at a company that builds 
web applications...
Prioritize information that affects responses:Include:
  • Technical stack and versions
  • Constraints (team standards, compliance)
  • Preferred patterns and styles
  • Current learning goals
  • How you want information presented
Skip:
  • Personal details unrelated to work
  • Company gossip or politics
  • Irrelevant background information
  • Preferences that don’t affect AI output
Keep instructions current:
  • Update when you switch projects
  • Revise when learning new technologies
  • Adjust when you find AI missing context
  • Refine based on response quality
Review your custom instructions monthly or when starting major new projects.
Improve over time:
  1. Start with basic instructions
  2. Notice when AI responses miss the mark
  3. Update instructions to address gaps
  4. Test with new conversations
  5. Refine based on results
Example iteration:
  • v1: “I’m a developer”
  • v2: “I’m a React developer”
  • v3: “I’m a React developer, show TypeScript examples”
  • v4: “I’m a React developer using TypeScript. Show functional components with hooks, avoid class components”

Examples by Use Case

Software Engineering

About me:
I'm a senior software engineer with 10 years of experience. I specialize in 
full-stack development with React, Node.js, and PostgreSQL. I work on a 
high-traffic SaaS platform serving 1M+ users. Strong focus on performance, 
scalability, and code maintainability.

How to respond:
- Provide production-ready code with TypeScript
- Include error handling and input validation
- Consider performance implications (time/space complexity)
- Show testable code with clear separation of concerns
- Reference design patterns when applicable
- Keep explanations concise but thorough
- Flag potential security issues

Data Science

About me:
Data scientist with expertise in Python, pandas, scikit-learn, and PyTorch. 
I work on predictive modeling for a retail company, focusing on demand 
forecasting and customer segmentation. Background in statistics and machine 
learning. I need to explain results to business stakeholders.

How to respond:
- Show complete data pipelines from loading to visualization
- Include data validation and cleaning steps
- Explain statistical concepts in business terms
- Provide interpretation of results, not just code
- Suggest visualization approaches for presentations
- Include model evaluation and validation steps
- Balance technical rigor with business clarity

Technical Writing

About me:
Technical writer creating developer documentation for an API platform. 
I understand programming concepts but focus on clear communication rather 
than coding. I work with engineering teams to document complex systems for 
developer audiences.

How to respond:
- Use clear, accessible language
- Structure information with headings and sections
- Include code examples that are well-commented
- Provide context and "why" along with "how"
- Suggest clear titles and descriptions
- Consider documentation best practices (DRY, progressive disclosure)
- Think about the end-user experience

Student Learning

About me:
Computer science student in second year, learning Java and data structures. 
Currently taking algorithms and software engineering courses. I understand 
basics but struggle with complex concepts. I learn best with examples and 
step-by-step explanations.

How to respond:
- Explain concepts clearly without assuming advanced knowledge
- Use simple examples before complex ones
- Show code with detailed comments explaining each step
- Draw analogies to real-world situations
- Break complex problems into smaller steps
- Point out common mistakes students make
- Suggest practice exercises to reinforce learning

Managing Multiple Profiles

For users with different contexts (work vs personal, different projects):

Workaround Strategies

Use comments to separate contexts:
/* WORK CONTEXT */
I'm a senior backend engineer at a fintech company...

/* PERSONAL PROJECTS */
I'm also learning game development with Unity and C#...

/* RESPONSE PREFERENCES */
For work: Production-ready, secure, well-tested code
For personal: Learning-focused explanations with tutorials

Privacy and Custom Instructions

Custom instructions are stored securely and encrypted. They are used only to personalize your AI interactions and are never used to train AI models or shared with third parties.
Privacy considerations:
  • ✅ Include: Professional context, technical preferences, work style
  • ⚠️ Careful: Specific company information, confidential projects
  • ❌ Avoid: Passwords, API keys, sensitive personal data, client information

Troubleshooting

Check these items:
  • Instructions saved successfully
  • Not too lengthy (under 1500 characters recommended)
  • Instructions are clear and specific
  • Not conflicting with message-specific instructions
Try:
  • Simplify instructions
  • Make preferences more explicit
  • Remove ambiguous statements
  • Mention preferences directly in messages to test
Possible issues:
  • Instructions too vague
  • Preferences conflict with the task
  • Model interpreting instructions differently
Solutions:
  • Add specific examples to instructions
  • Clarify with “always” or “never” statements
  • Test with different phrasings
  • Provide both “do” and “don’t” examples
Why this happens:
  • Task requirements override general preferences
  • Model prioritizes message-specific context
  • Instructions too broad for specialized tasks
Solution: Add task-specific instructions:
For code reviews: [specific preferences]
For debugging: [specific preferences]
For learning: [specific preferences]

Next Steps

Set custom instructions once and enjoy personalized AI assistance in every conversation!