Custom Instructions - ZeroTwo Docs

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

Open Settings

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

Navigate to Custom Instructions

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

Fill in your preferences

You’ll see two main sections:

About You: Context about yourself
Response Preferences: How you want AI to respond

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

Professional background

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.

Goals and projects

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.

Preferences and constraints

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.

Context and interests

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

Developer
Data Scientist
Student
Product Manager

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.

I'm a data scientist working in healthcare analytics. I primarily use 
Python with pandas, scikit-learn, and PyTorch. I have a statistics 
background and focus on predictive modeling and time series analysis. 
I need to explain technical concepts to non-technical stakeholders 
regularly.

I'm a computer science student in my third year, learning algorithms, 
data structures, and software engineering. I'm comfortable with Python 
and Java, currently taking courses in machine learning and distributed 
systems. I learn best with clear explanations and practical examples.

I'm a product manager for a SaaS platform. I work closely with 
engineering teams and need to understand technical concepts well enough 
to make informed decisions, but I'm not writing code myself. I focus on 
user experience, feature prioritization, and product strategy.

Response Preferences Section

Define how you want AI to format and structure responses.

Response Style

Formality Level
Detail Level
Technical Depth

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.

Control verbosity:Concise:

Keep responses brief and to the point. Only include essential 
information. Avoid lengthy explanations unless I specifically ask.

Detailed:

Provide comprehensive, detailed explanations. Include background 
context, edge cases, and thorough examples. Don't assume prior knowledge.

Balanced:

Give clear explanations with enough detail to understand, but stay 
focused. Offer to elaborate if needed.

Set expertise level:Advanced:

Use advanced technical terminology. Don't oversimplify. I want 
deep technical details, performance implications, and best practices.

Intermediate:

Balance technical accuracy with clarity. Explain complex terms when 
first used, but don't oversimplify concepts.

Beginner-Friendly:

Explain technical concepts clearly without jargon. Define terms when 
they're necessary. Use analogies to clarify complex ideas.

Output Format Preferences

Code formatting

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

Structure and organization

Response structure:

When answering questions:
Start with a brief direct answer
Provide detailed explanation
Include practical code examples
List edge cases and considerations
Suggest next steps or related topics

Use bullet points for lists and numbered steps for procedures.

Documentation style

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

Explanation approach

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

Developer - Concise
Developer - Detailed
Data Analyst
Content Creator

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.

Provide comprehensive explanations with detailed code examples. Include:
- Inline comments explaining the logic
- Alternative approaches with trade-offs
- Performance considerations
- Security implications
- Testing suggestions
- Links to relevant documentation

Always use TypeScript and show complete, production-ready code. Explain 
why certain patterns or approaches are preferred.

When working with data:
- Show Python code with pandas and matplotlib
- Include data validation and cleaning steps
- Explain statistical concepts simply
- Provide visualization recommendations
- Show how to interpret results
- Suggest ways to present findings to non-technical audiences

Balance technical accuracy with business clarity.

For writing and content:
- Use clear, engaging language
- Structure with headings and short paragraphs
- Include practical examples
- Make technical topics accessible
- Suggest SEO-friendly titles and descriptions
- Keep sentences concise and scannable

Aim for content that's informative but easy to read.

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:

Web Development
DevOps
Machine Learning
Academic Research

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

For DevOps and infrastructure:
- Provide infrastructure as code (Terraform preferred)
- Include monitoring and logging considerations
- Show both development and production configurations
- Consider security and compliance requirements
- Explain cost implications for cloud resources
- Follow the 12-factor app methodology

For ML projects:
- Show data preprocessing and cleaning steps
- Include model evaluation metrics
- Discuss overfitting/underfitting considerations
- Provide code for both training and inference
- Suggest hyperparameter tuning approaches
- Consider computational cost and scalability

For research help:
- Cite sources and reference relevant papers
- Explain methodology rigorously
- Discuss limitations and assumptions
- Use proper academic terminology
- Suggest statistical tests when applicable
- Format according to academic standards

Tips for Effective Custom Instructions

Be specific but concise

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...

Focus on what matters

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

Update regularly

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.

Test and iterate

Improve over time:

Start with basic instructions
Notice when AI responses miss the mark
Update instructions to address gaps
Test with new conversations
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

Comment Sections
Primary Focus
Update Before Sessions

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

Set instructions for your primary use case:

Primary context: Professional software development
[Detailed work instructions]

Note: When I mention "personal project" or "learning", adjust to be 
more educational and exploratory rather than production-focused.

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

Custom instructions not being followed

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

Responses too different from expectations

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

Instructions seem ignored for specific tasks

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

Assistants

Create specialized assistants with custom instructions

Prompts Guide

Learn advanced prompting techniques

Memory System

Understand how AI remembers context

Settings

Explore other customization options

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

​Custom Instructions Overview

​Why Use Custom Instructions?

Save Time

Consistent Responses

Personalized AI

Better Results

​Setting Custom Instructions

​About You Section

​What to Include

​Good “About You” Examples

​Response Preferences Section

​Response Style

​Output Format Preferences

​Good Response Preferences Examples

​Advanced Custom Instructions

​Using Variables

​Conditional Instructions

​Domain-Specific Instructions

​Tips for Effective Custom Instructions

​Examples by Use Case

​Software Engineering

​Data Science

​Technical Writing

​Student Learning

​Managing Multiple Profiles

​Workaround Strategies

​Privacy and Custom Instructions

​Troubleshooting

​Next Steps

Assistants

Prompts Guide

Memory System

Settings

Custom Instructions Overview

Why Use Custom Instructions?

Setting Custom Instructions

About You Section

What to Include

Good “About You” Examples

Response Preferences Section

Response Style

Output Format Preferences

Good Response Preferences Examples

Advanced Custom Instructions

Using Variables

Conditional Instructions

Domain-Specific Instructions

Tips for Effective Custom Instructions

Examples by Use Case

Software Engineering

Data Science

Technical Writing

Student Learning

Managing Multiple Profiles

Workaround Strategies

Privacy and Custom Instructions

Troubleshooting

Next Steps