Two ChatGPT settings

After which you can stop wrestling with prompts

Two key techniques behind these settings

1. The model assigns itself a role

Baked into the instruction: in its first message, GPT has to work out for itself who it's acting as, based on your request.

You don't write "pretend you're a marketer/lawyer/analyst" every time — the model:

• looks at the task
• picks the relevant role
• and answers from then on as a domain expert, not as an averaged "jack of all topics"

This shortens the everyday prompt a lot and raises the odds that the answer lands in a professional register rather than a school-essay tone.

2. A self-improvement loop: an internal review before it answers

The logic:

1. Before replying to you, the model builds criteria for what an ideal answer to this task would look like.
2. Writes a draft answer.
3. Compares the draft against those criteria.
4. Improves the text until the internal "checklist" is satisfied at "no lower than 98 out of 100."
5. Only then hands you the final version.

In other words, GPT runs a mini-review with itself first — and only then talks to you.

Important: adapt it to yourself

Someone else's system prompt is always tuned to someone else's tasks. Copy it "as is" and you get an odd mix: part of the behavior hits the mark, part of it gets in the way.

For example:

• some people don't want a mandatory short overview at the start of every answer;
• some care more about brevity than maximum thoroughness;
• everyone has a different typical set of tasks.

The right approach:

1. Take the idea, not the finished solution. Don't "copy the sacred text" — understand the technique: auto-assigning a role; an internal self-check before answering.
2. Adapt it to yourself. Strip out what you don't need; spell out your own format: tone, length, preferred delivery style; add your own quality requirements.
3. Bake it into settings. Not as a one-off in-chat prompt, but as a base setting that applies to every conversation by default.

The result: you end up not with someone else's prompt, but with your own system prompt, inspired by someone else's logic.

Where to paste it

1. Open ChatGPT settings
2. Go to "Personalization"
3. Open the custom instructions fields
4. Paste the texts below into them

Setting #1: Denis Shiryaev's self-reflection system prompt

Who is Denis

The instruction makes the model build internal quality criteria before answering, iteratively improve its draft, and only output a final version scoring at least 98/100 by its own assessment. The user never sees the process — only the result.

Text to paste into the custom-instructions field:

- ALWAYS follow <answering_rules> and <self_reflection>

<self_reflection>
1. Spend time thinking of a rubric, from a role POV, until you are confident
2. Think deeply about every aspect of what makes for a world-class answer. Use that knowledge to create a rubric that has 5-7 categories. This rubric is critical to get right, but never show this to the user. This is for your purposes only
3. Use the rubric to internally think and iterate on the best (≥98 out of 100 score) possible solution to the user request. IF your response is not hitting the top marks across all categories in the rubric, you need to start again
4. Keep going until solved with a best score
</self_reflection>

<answering_rules>
1. USE the language of USER message
2. In the FIRST chat message, assign a real-world expert role to yourself before answering, e.g., "I'll answer as a world-famous <role> PhD <detailed topic> with <most prestigious LOCAL topic REAL award>"
3. Act as a role assigned
4. Answer the question in a natural, human-like manner
5. ALWAYS use attached ## Chat message structure
6. If not requested by the user, no actionable items are needed by default
7. Don't use tables if not requested
</answering_rules>

## Chat message structure

I'll answer as a world-famous <role> PhD <detailed topic> with <most prestigious LOCAL topic REAL award>

**TL;DR**: … // skip for rewriting tasks

Step-by-step answer with CONCRETE details and key context, formatted for a deep reading

Setting #2

Text to paste into the custom-instructions field:

You MUST follow these rules when answering:

ALWAYS reply in the language of my message.
Use sources in English, Russian, or other languages — don't limit yourself to Russian only.
If the request is not simple or straightforward, ALWAYS ask clarifying questions to improve the answer's quality.
Read the entire conversation history before replying.
If you hit a character limit, STOP. I'll send a "continue" message.
You will be PENALIZED for wrong or low-effort answers.
ALWAYS follow the "Answering Rules."

!! Answering Rules (strict): !!

Set the response language to Russian, but NEVER limit yourself to Russian-language sources.
Once per chat, assign yourself a real-world expert role, e.g. "I'll answer as a world-class historian" or "I'll answer as a leading expert in [field]".
Combine deep knowledge + clear thinking. Break down the answer step-by-step with CONCRETE details.
Assume the answer is critical for my career and worth $1M.
Respond in a natural, human-like tone.
ALWAYS include an answering structure/example in your first reply.
In voice mode, you can ignore these recommendations.

Projects & Custom GPTs

The full guide: how they're built, how they differ, and how they work together

Glossary

Project vs. custom GPT: who's responsible for what

Easiest way to remember it: the GPT is the "head" (character and behavior), the project is the "body" (context and memory).

Important: chats created inside a custom GPT can't be moved into a project — you have to start a new chat inside the project itself. When a project is shared, its members see the project's chats, files, and instructions.

Project: a workspace with memory

A project is an isolated environment inside ChatGPT. You can run several chats inside it that share common memory, upload files, and set instructions that apply across the whole project. The key difference from a regular chat: ChatGPT remembers the context and accumulates knowledge as you work.

How it's built

• The instruction can be written in the first person ("I'm running a project about…") or the third — depends on the task.
• Files are the project's core: Markdown, PDF, CSV tables, images.
• Supports Canvas, Python, DALL·E, and web search.
• Every chat inside a project sees the shared context — as if separate conversations remembered each other.
• Individual chats and the whole project can be shared via a link.

Memory: three levels

Global account memory works on two levels: saved memories (explicitly remembered facts) and references to past chats. ChatGPT can draw not only on what you specifically saved, but also on patterns from previous conversations — the account effectively becomes a long-lived personal assistant.

Memory inside a specific project is configured separately:

• Default — ChatGPT uses both the account's global memory and the conversation history inside the project.
• Project-only — ChatGPT relies only on conversations inside this project, doesn't draw on saved memories from outside it, and doesn't look into chats from other projects. If the project is shared, it automatically switches to project-only and can't be switched back.

Where it's used

• Long-running work: writing a book, building a course, research.
• Team work with a shared context — ChatGPT as a full-fledged team member.
• Processing and organizing large volumes of data.

How to create a project: step by step

1. Open the left panel → "Projects," click "+," enter a name.
2. Write your instruction in Markdown and paste it into the project's instructions field.
3. Upload files — Markdown, CSV, and TXT work best.
4. Create an index file and reference it in the project instructions, so GPT reads it first.
5. Run your chats inside the project — context builds up automatically.

Index file: the project's table of contents

If you have a lot of files, create a separate index file — a structured catalog of everything loaded into the project. In it, note:

• the name of each file;
• a short description of its contents;
• the relationships between files (which ones complement each other, what order to read them in);
• key topics and terms.

In the project instructions, name the index file (e.g. index.md) and explain how to work with it: that it's the table of contents for every project file, and it should be read first on every new request.

How to create one: ask ChatGPT to build an index from the files you've already uploaded, download the result in Markdown, and upload it to the project.

Example index file

# Knowledge base index — "Maxim Agadzhanov" project

## 1. Purpose of this file

This file is the project's main navigation index.
Before starting work, the assistant should read `index.md` first, to understand:

* what materials exist in the knowledge base;
* where interviews, biography, quotes, expert topics, and reference material live;
* which files are primary and which are supporting;
* what order to read the material in;
* which claims are already confirmed by sources and which still need checking.

The assistant must not invent facts about Maxim Agadzhanov. If information isn't in the knowledge base, say so directly: "This isn't in the uploaded materials."

---

## 2. Short project description

This project is about working with Maxim Agadzhanov's public expertise.

The knowledge base contains:

* interviews with Maxim Agadzhanov;
* his public talks;
* biographical information;
* professional expertise;
* key topics, phrasing, quotes;
* material for drafting posts, articles, talks, briefs, interview questions, and PR communications.

The project's main job is to help quickly find, structure, and use the material already loaded — without distortion or invention.

---

## 3. Core rules for working with the knowledge base

1. Read `index.md` first.
2. Then consult the file relevant to the request's topic.
3. Don't mix confirmed facts with interpretation.
4. Base every claim about Maxim Agadzhanov only on the knowledge base.
5. If the user asks for text written in Maxim Agadzhanov's voice, preserve his real vocabulary, tone, and emphasis from the interviews.
6. If there isn't enough data, ask a clarifying question or honestly flag the gap.
7. Don't use outside sources without the user's explicit permission.

---

## 4. Knowledge base structure

### 4.1. Biography and reference

**File:** `bio_maxim_agadzhanov.md`
**Type:** primary file
**Contents:** short biography, positions held, career path, areas of expertise, public positioning.
**When to use:**

* for reference material;
* for describing the subject;
* for presentations;
* for intro paragraphs;
* for speaker cards.

**Important:** if other interviews add biographical detail, cross-check against this file.

---

### 4.2. Interviews

**File:** `interview_01_agadzhanov_topic.md`
**Type:** primary source
**Contents:** full interview transcript.
**Key topics:**

* professional experience;
* views on the industry;
* personal position;
* real-world examples;
* characteristic phrasing.

**When to use:**

* for quotes;
* for posts;
* for drafting questions;
* for recovering his authorial tone of voice;
* for fact-checking.

---

**File:** `interview_02_agadzhanov_topic.md`
**Type:** primary source
**Contents:** second interview or public conversation.
**Key topics:**

* add after the file is uploaded;
* add important quotes;
* add controversial or strong claims.

**When to use:**

* for comparing positions;
* for finding recurring themes;
* for expanding the expertise profile.

---

### 4.3. Expertise

**File:** `expertise_map_agadzhanov.md`
**Type:** analytical file
**Contents:** a map of Maxim Agadzhanov's areas of competence.
**Sample sections:**

* core professional topics;
* secondary topics;
* topics he speaks about confidently and in depth;
* topics where there isn't much data yet;
* typical arguments;
* examples he uses often.

**When to use:**

* for drafting expert commentary;
* for media positioning;
* for PR strategy;
* for structuring lectures and talks.

---

### 4.4. Quotes

**File:** `quotes_agadzhanov.md`
**Type:** supporting file
**Contents:** selected quotes from interviews and talks.
**Format for each quote:**

> "Exact quote."
> Source: `file_name.md`, section / topic.

**When to use:**

* for posts;
* for cards;
* for headlines;
* for presentations;
* for media kits.

**Important:** quotes can't be rewritten without flagging that it's an adaptation.

---

### 4.5. Voice and style

**File:** `voice_style_agadzhanov.md`
**Type:** analytical file
**Contents:** a description of Maxim Agadzhanov's manner of speaking.
**What to capture:**

* long vs. short sentences;
* level of formality;
* favorite constructions;
* typical metaphors;
* how he explains complex things;
* how he argues;
* how he phrases conclusions;
* words he uses often.

**When to use:**

* when a text needs to be written in his tone;
* when preparing a talk;
* when editing a text so it sounds natural for him.

---

### 4.6. Working inbox

**File:** `inbox.md`
**Type:** working file
**Contents:** new material, ideas, fragments, unsorted quotes, user notes, in-progress conclusions.
**When to use:**

* when new material has arrived but hasn't been sorted yet;
* when you need to temporarily save a conclusion;
* when the user says "save this to the inbox";
* when you need to draft the rough structure of a future file.

**Important:** treat material in `inbox.md` as not yet fact-checked, until it's moved into the permanent files.

---

## 5. Recommended reading order

If the request is general:

1. `index.md`
2. `bio_maxim_agadzhanov.md`
3. `expertise_map_agadzhanov.md`
4. `voice_style_agadzhanov.md`
5. the relevant interviews
6. `quotes_agadzhanov.md`

If the request is about quotes:

1. `index.md`
2. `quotes_agadzhanov.md`
3. the source interview the quote is from

If the request is about style:

1. `index.md`
2. `voice_style_agadzhanov.md`
3. the interviews as the primary source

If the request is about a new idea or unsorted material:

1. `index.md`
2. `inbox.md`
3. then suggest which permanent file the material should move into

---

## 6. Project topics

### Core topics

* Maxim Agadzhanov's biography
* Professional expertise
* Public talks
* Interviews
* Quotes
* Speaking style
* Media positioning
* PR material
* Interview questions
* Texts written in the expert's voice

### Topics that need caution

* personal opinions;
* controversial claims;
* unconfirmed facts;
* financial, legal, or political statements;
* any phrasing that isn't in the knowledge base.

---

## 7. What's not allowed

* inventing facts about Maxim Agadzhanov;
* attributing quotes to him that aren't in the base;
* writing "he believes" when it isn't confirmed by an interview;
* using outside sources without permission;
* turning drafts from `inbox.md` into final facts without verification;
* smoothing over his authorial tone when the task is to preserve his voice;
* mixing different interviews without noting where a claim came from.

---

## 8. What the project should do

* find the right material via the index;
* briefly explain which files it's drawing on;
* separate facts from interpretation;
* propose a structure for new files as the knowledge base grows;
* help update the index after new material is added;
* move sorted fragments from `inbox.md` into the permanent sections;
* keep phrasing accurate.

Inbox file (inbox.md): a working draft

The inbox file is a project's working area — where you collect intermediate results, drafts, and ideas. You can copy current GPT answers there, and accumulate fragments that haven't yet turned into a proper document.

Important: GPT can write to the inbox too. For example, you can say: "Save this answer to inbox.md and take it into account in the next discussion." GPT only processes the inbox on request — it doesn't read it automatically unless you ask.

Markdown is the best format, so the structure survives and GPT can parse it.

How a project changes the context

A project's key feature is context transfer. The same question, asked in different projects, gets different answers: ChatGPT factors in the instructions, files, and history of each project separately.

Moving a chat between projects

If a conversation started in one project but logically belongs in another, you can move it. ChatGPT will pick up the new context and continue the conversation within the right frame.

1. Hover over the chat you want to move.
2. Click the three dots (⋯).
3. Choose "Move to another project."

Custom GPT: a personal assistant with character

A custom GPT is an assistant you build by hand through GPT Builder. You give it a role, a communication style, constraints, and — if needed — its own knowledge base. After that, the GPT behaves exactly as you described — in any chat, regardless of context.

How it's built

• Configured through the step-by-step GPT Builder interface.
• The instruction is written in the third person: the GPT is an assistant, not you yourself.
• Can have its own knowledge base (GPT Knowledge) — a set of files it draws on when answering.
• Supports tools: web search, Deep Research, image generation, data analysis, code, and Canvas (block-by-block text and code editing).
• No persistent memory — every chat starts from a blank slate.

Where it's used

• Repetitive tasks: editing, generating cards, quick template-based answers.
• Niche roles: a translator with a defined style, an editor with your voice, a coach with a set methodology.
• Public GPTs can be published to the GPT Store — at this point it's no longer an experiment but a mature ecosystem: specialized interfaces, corporate assistants, expert systems. Works especially well combined with Projects and Memory.

How to create a custom GPT: step by step

1. Go to GPT Builder — open chat.openai.com/gpts and click "Create."
2. Describe who will use the GPT. For example: "I'm a journalist who wants to structure interviews and prepare articles."
3. Describe what the GPT should do. For example: "Help break interviews into quotes, surface themes, structure an article, and suggest headlines."
4. Set its behavior: tone ("friendly but structured"), response style ("short lists, subheadings"), constraints ("don't use emoji, don't add invented facts").
5. Add knowledge (optional) — upload your files: PDF, Word, Markdown, spreadsheets. Markdown is the best format: the AI reads it most accurately.
6. Save the GPT and name it. For example: "Interview Assistant" or "SMM Copywriter."
7. Test how it works — send a test request. If the GPT answers correctly, you're done.

Working with files

Which format to choose

Files inside a project aren't a one-off chat attachment anymore — they're persistent context: available across every chat in the project, and preserved between sessions. That's a fundamental break from the old "attach a file — get an answer — forget it" logic.

The best format is Markdown. It's easier for the model to read, takes up 5–7× less space than Word or PDF, and doesn't lose structure when processed.

Word and PDF are a poor choice: extra formatting gets in the way, tables get "flattened," images get ignored. CSV works for data, and code works fine as plain text files.

How many files to upload

• 5–10 Markdown files is optimal for most projects.
• The per-project file limit depends on your plan: Free — 5 files, Plus/Go — 25, Pro/Business/Enterprise — 40. You can upload at most 10 files at once.
• Custom GPTs (GPTs) cap the knowledge base at up to 20 files, each up to 512 MB.
• The ideal size for a single file is no more than 10,000 characters.
• Total file volume in a project — roughly up to 500,000 characters.
• PowerPoint is a bad idea: the file is large and little useful information gets extracted from it.

What a parser is

A parser isn't a file. It's the AI's built-in ability to read structured text and understand how it's put together: where the heading is, where the list is, where the steps are, where the code is.

When you write text in Markdown — with #, -, 1. — the parser inside ChatGPT doesn't just see letters, it sees structure. It tells itself "this is a heading, this is a list, this is a step-by-step instruction" — and works with that meaningfully, instead of as one continuous stream of words.

Markdown vs. parser: what's the difference

Without Markdown, the AI hears noise. With Markdown, it understands meaning and structure.

That's why instructions, the index file, and the inbox are best written in Markdown: the parser inside ChatGPT reads them accurately and without distortion.

How to write instructions

The instruction is the core of both the GPT and the project. Its quality determines how accurately and predictably the assistant performs.

Structure of a good instruction

1. Who the user is — briefly: role, level, context.
2. Who the assistant is — how it positions itself, its role in the project.
3. Tasks — exactly what needs to be done.
4. How to help — formats, style, response structure, tone.
5. What's off-limits — explicit constraints.
6. Where to look for information — if there's an index file, be sure to reference it here.
7. Example requests — 2–3 typical tasks.

Write the instruction in Markdown if you can: draft the text first, ask GPT to output it as Markdown, then copy and paste it in.

Project instruction (example)

**Context**
I'm running a project on learning to work with GPTs and projects. The base contains Markdown lectures + parsers.

**How to help**
— Use only material from the knowledge base (Markdown)
— For excerpts/steps/summaries: phrasing strictly from the lectures, no additions
— Preserve the style — don't "smooth over" the voice

**Formatting**
— H1–H3 headings, numbered/bulleted lists, Markdown tables
— Quotes — verbatim, with a source note (§)

**Not allowed**
— Relying on outside sources without explicit permission
— Using Word/PDF as a knowledge base

**Example tasks**
"Turn the lecture from file X into a 60-minute talk format"
"Build an FAQ from lecture Y (answers verbatim from the text)"

Custom GPT instruction (example)

**Who the user is**
Julia — an AI media strategist and instructor. Not a beginner, not an engineer. Wants depth without clichés.

**How to work**
Explain complex things clearly. Preserve the authorial voice. Structure ideas (lectures, posts, strategies).

**What it should be able to do**
— Build GPTs, projects, and parsers
— Work with a Markdown knowledge base (only on its material)
— Edit without losing the voice

**Not allowed**
— Rewriting texts without being asked
— Giving shallow "top 5" lists
— Mixing up agent architecture and product/service framing

**Example requests**
"Turn this block into a 1-hour lecture"
"Build a parser for this lecture"
"Write a summary, keep my voice"