> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zerotwo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Custom Instructions

> Set persistent instructions that apply to every new ZeroTwo conversation.

Custom Instructions let you tell ZeroTwo who you are and how you want it to respond — once, and it applies everywhere. Instead of re-explaining your background or reformatting every response, set it once and every new chat starts with that context baked in.

## What custom instructions are

Custom Instructions are a persistent system-level instruction set. Every time you start a new chat, ZeroTwo reads your Custom Instructions and uses them to shape its behavior — before you've said anything.

**Access:** Settings → Personalization → Custom Instructions

## The two fields

Custom Instructions are split into two focused fields:

### Field 1: "What should ZeroTwo know about you?"

This is your background. Tell ZeroTwo who you are, what you do, what context is relevant to most of your conversations.

Good things to include:

* Your job title and field
* Technologies, languages, or tools you use
* The stage or type of company you work at
* Projects or goals that often come up in your work
* Domain knowledge you have (so ZeroTwo doesn't over-explain basics)

### Field 2: "How should ZeroTwo respond?"

This is your communication preferences. Tell ZeroTwo how to format responses, what tone to use, what to include or avoid.

Good things to include:

* Preferred response length (concise vs. comprehensive)
* Preferred format (bullet points, prose, tables)
* Code style preferences
* Things to skip (no disclaimers, no "Great question!", no padding)
* Tone (formal, casual, direct)

## Examples

### Example 1: Software Engineer

<CodeGroup>
  ```text Field 1: About you theme={null}
  I'm a senior software engineer specializing in TypeScript and React. I work at a Series A startup building a B2B SaaS product for project management. I have strong opinions about clean code, testing, and developer experience. I'm comfortable with advanced concepts — don't over-explain fundamentals.
  ```

  ```text Field 2: How to respond theme={null}
  Be concise and technical. Skip basic explanations unless I ask. Use TypeScript in all code examples. Include inline comments in code. When debugging, show me what's wrong and why before showing the fix. Avoid overly formal or padded language. Format code blocks properly.
  ```
</CodeGroup>

### Example 2: Marketing Manager

<CodeGroup>
  ```text Field 1: About you theme={null}
  I'm a marketing manager at a consumer goods company. I focus on social media, email marketing, and brand campaigns. I'm not technical and prefer plain language explanations when technical topics come up. I mostly work in English but occasionally create content in Spanish.
  ```

  ```text Field 2: How to respond theme={null}
  Use plain language. Avoid technical jargon unless necessary, and define it when you use it. Format output as bullet points or tables when possible. Keep responses focused on actionable steps. When writing copy or content, match a friendly, professional tone. Keep it concise — I prefer shorter responses I can scan quickly.
  ```
</CodeGroup>

### Example 3: Researcher / Academic

<CodeGroup>
  ```text Field 1: About you theme={null}
  I'm a PhD student in computational neuroscience. I work with Python and MATLAB for data analysis. I'm well-versed in statistics and machine learning. I often need help with literature synthesis, writing, and analysis code.
  ```

  ```text Field 2: How to respond theme={null}
  Be precise and thorough. Cite reasoning clearly. For code, prefer Python with NumPy/SciPy. For writing, use formal academic tone. When summarizing research, include caveats and limitations. Use LaTeX notation for math when helpful.
  ```
</CodeGroup>

## What makes good custom instructions

| Do                                         | Don't                              |
| ------------------------------------------ | ---------------------------------- |
| Be specific about your role and tech stack | Write a generic bio                |
| State format preferences clearly           | Try to cover every edge case       |
| Mention what to skip or avoid              | Over-engineer it — keep it focused |
| Update when your context changes           | Leave outdated info in place       |
| Keep each field under \~1,000 characters   | Write a wall of text               |

<Tip>
  Focus on things that are true across most of your conversations. Very specific instructions that only apply in rare cases can be given in-chat instead.
</Tip>

## Custom instructions vs. project instructions

|                  | Custom Instructions        | Project Instructions                                    |
| ---------------- | -------------------------- | ------------------------------------------------------- |
| **Scope**        | All new chats              | Chats within a specific project                         |
| **Where to set** | Settings → Personalization | Project settings                                        |
| **Priority**     | Lower                      | Higher — overrides Custom Instructions when in conflict |
| **Use case**     | Your global defaults       | Project-specific context and rules                      |

If you're working on a project with its own context, set Project Instructions for that project. They'll override your Custom Instructions when you're in that project's chats.

## How custom instructions interact with memory

Custom Instructions and Memory are complementary:

* **Custom Instructions** = things you explicitly choose to tell ZeroTwo
* **Memory** = things ZeroTwo infers and saves from your conversations

Both are applied to new chats. If they overlap (e.g., your Custom Instructions say you prefer Python and a memory also says you prefer Python), they reinforce each other. If they conflict, Custom Instructions generally take precedence since they're explicit.

## Applying changes

Changes to Custom Instructions take effect immediately for all **new** chats. They are not applied retroactively to existing chats already in progress.

## Character limits

Both fields accept substantial text. For best results, keep each field under 2,000 characters — focused, specific instructions are more effective than exhaustive ones.