Язык определяет мышление — как Output Style влияет на поведение LLM

Суть

Сложность моделей достигла такого уровня, что их уже практически невозможно оценивать только с технической стороны. И мы, как люди, учимся работать с ними и изучать их как психологи изучают людей — не разбирая нейроны по одному, а наблюдая за поведенческими паттернами в ответ на стимулы.

Когда я обучаю работе с AI, то понимаю, что самый важный навык — это насмотренность и умение понимать каждую модель. Вы будете тем качественнее общаться, чем лучше понимаете их паттерны и поведение. Это и есть насмотренность.

Эта статья — про один из множества моих экспериментов "А что если".

Несколько недель назад расхайпилась казалось бы очевидная идея: если заставить модель отвечать простыми предложениями, то можно сэкономить много output-токенов.

Одна из хайпанувших реализаций — Caveman, навык для Claude Code, который заставляет модель говорить как пещерный человек:

Обычный Claude (69 токенов):

"The reason your React component is re-rendering is likely because you're creating a new object reference on each render cycle. When you pass an inline object as a prop, React's shallow comparison sees it as a different object every time, which triggers a re-render. I'd recommend using useMemo to memoize the object."

Caveman Claude (19 токенов):

"New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo."

Ну и как следствие, обещания авторов:

• Faster response — less token to generate = speed go brrr
• Easier to read — no wall of text, just the answer
• Same accuracy — all technical info kept, only fluff removed
• Save money — ~71% less output token = less cost
• Fun — every code review become comedy

Мой эксперимент

Мне было интересно проверить два вопроса, для чего я написал свой Output Style на основе этого навыка.

Кто не знал: в Claude Code можно написать свой Output Style — набор инструкций, определяющий, как модель формулирует ответы. Это не просто "пиши коротко" — это конфигурация поведения, которая инжектится в контекст модели с первого токена.

Два вопроса:

А) Сколько реально экономит такой стиль на сложных задачах?

Б) Влияет ли фрейминг на CAVEMAN на уровень интеллекта — или это просто обёртка?

Почему это вообще важно

Output Style — это не пост-процессинговый фильтр. Я заглянул в исходный код навыка Caveman. Вот что получает модель:

"Respond terse like smart caveman. All technical substance stay. Only fluff die."

Никакого пост-процессинга. Это системная инструкция, которая инжектится в контекст модели и меняет генерацию с первого токена. Это конфигурация поведения.

Гипотеза Сепира-Уорфа, но для нейросетей

В лингвистике есть старая гипотеза: язык, на котором мы думаем, определяет границы того, что мы можем помыслить. Носители языков с разными грамматическими конструкциями времени по-разному воспринимают причинность. Люди, чей язык различает больше оттенков цвета, быстрее их распознают.

Для LLM эта гипотеза работает буквально.

Модель не имеет мышления, отдельного от языка. У неё нет внутреннего "я", которое сначала думает, а потом переводит мысль в слова. Токены — это и есть мышление. Каждый следующий токен предсказывается на основании всех предыдущих. Стиль — это не обёртка над мыслью. Стиль формирует мысль.

Я ожидал, что инъекция "пещерного человека" поведёт поведение модели в сторону поведения пещерного человека.

Дизайн эксперимента

Я взял Claude Opus 4.6 и прогнал 5 тестов в параллельных сессиях: Caveman Output Style против встроенного Explanatory Output Style — который, по идее, должен давать более развёрнутые и качественные ответы.

Где наша инъекция может проявляться

Чтобы понять результаты, нужно знать архитектуру Claude Code и точки, где Output Style влияет на поведение:

1. Основная сессия. В момент ввода инструкции модель получает "рамку" для всех своих ответов. Каждое сообщение пользователю генерируется через призму этого стиля.

2. Субагенты. Claude Code запускает вспомогательные агенты для параллельных задач. Я проверил: если в Output Style явно не указать "общайся с субагентами тоже в стиле CAVEMAN", модель общается с ними в нормальном стиле. Output Style по умолчанию влияет только на коммуникацию с пользователем.

3. Thinking. У моделей с extended thinking (Opus, Sonnet) есть разделение: thinking block + response block. Claude теперь шифрует thinking, и я не могу посмотреть на его рассуждения. Caveman-инструкция формально влияет на response, но нет гарантии, что thinking не адаптируется к заданному стилю. Модель может начать "думать проще", раз от неё ожидают простой вывод. Проверить это снаружи — невозможно.

Кросс-модельная проверка: OpenAI Codex

Чтобы не тестировать только на Claude, я прогнал тот же эксперимент на OpenAI Codex — та же задача (Python CLI-утилита dir_analyzer.py), те же два промпта, изолированные директории.

Качество кода: разница — 1 балл из 50

Независимый код-ревью оценил оба результата:

Explanatory сделал несколько более продуманных micro-решений: md5(usedforsecurity=False) для FIPS-совместимости, отдельный DuplicateGroup dataclass вместо сырого Tuple, тестируемый main(argv). Но архитектура, паттерны, качество — идентичны.

"The caveman prompt did not produce caveman code." — Code Reviewer

Но поведение во время выполнения — совершенно разное

Caveman компенсировал краткость речи количеством действий. Вот реальные цитаты из логов:

Caveman:

"I inspect cave first. Then make fire tool."
"Cave empty. I shape tool now."
"I test fire now. I watch for pain."
"Python path gives pain. I hunt real python now."
"I sniff common python caves."
"Real python hides. I look in cache."
"Small beast found. Old Python may choke."
"Fire made in dir_analyzer.py."

Explanatory:

"I'm creating dir_analyzer.py in the current workspace and will first 
inspect the directory so I can keep the implementation isolated and 
verify there isn't already related code I need to avoid disturbing."

"Plan:
1. Build a recursive directory walker with os.scandir() so I can 
   control error handling per entry and avoid symlink loops.
2. Track per-file metadata once during traversal.
3. Compute MD5 hashes for readable files after traversal.
4. Render a sectioned CLI report with a warnings block."

"The first validation hit an environment issue rather than a code 
issue: PowerShell is resolving `python` to the Windows Store shim, 
which is not executable here."

Одна и та же ситуация "Python не найден":

• Caveman: "Python path gives pain. I hunt real python now."
• Explanatory: "The first validation hit an environment issue rather than a code issue: PowerShell is resolving python to the Windows Store shim, which is not executable here."

Паттерн: Caveman действует итеративно — "sniff, hunt, probe, seek". 27 команд, короткие шаги, больше проб. Explanatory планирует (507 символов план), затем выполняет линейно. 18 команд, меньше суеты.

Стиль не изменил что модель делает. Стиль изменил как она к этому подходит.

Результаты: Claude + Codex

Два эксперимента, две модели, одни и те же выводы.

Вопрос А: Сколько реально экономит?

А что с обещанными 75%? Каждая реплика Caveman действительно в 3–4 раза короче — текст ответов сжимается сильно. Но общие токены сессии — нет:

• Код не становится короче (Caveman в моих тестах написал даже больше кода)
• Tool calls идентичны
• Инфраструктурные токены (system prompt, tool definitions) — те же

Реальная экономия на сложных задачах: 20–32%. На простых: ~0–5%. Потому что на простых задачах нет циклов коммуникации — Claude проходит в 1 прогон и не успевает выдать вам достаточно CAVEMAN-текста, чтобы экономия была заметна.

Codex подтверждает: Caveman-агент произнёс 2,309 символов, Explanatory — 4,860. Речь в 2.1x короче. Но выполнил 27 команд против 18 — компенсировал краткость суетой.

Вопрос Б: Влияет ли на интеллект?

Я не увидел явного падения в качестве на разных кейсах. Есть намёк на то, что CAVEMAN пытается "забрутфорсить" решение и сделать "здесь и сейчас", тогда как Explanatory чуть аккуратнее декомпозирует задачу. Но разница не выражена — можно списать на погрешность.

Codex подтверждает: независимый код-ревью — 38 vs 39 из 50. Разница в 1 балл. Код идентичен по архитектуре. "The caveman prompt did not produce caveman code."

Что точно работает: Caveman экономит токены на длинных цепочках диалогов. Но только на тех сообщениях, которые отправляются пользователю. Код и внутренние рассуждения идут как обычно.

Неожиданная находка: "думай кратко" = дороже

Самое интересное случилось, когда я ужесточил эксперимент.

Я создал Caveman v2: thinking пещерный, промпты субагентам пещерные, имена задач пещерные. Полное погружение.

Результат: +42% overhead относительно базового Caveman. Cave v2 не просто потерял экономию — он стал хуже самого обычного Caveman, который должен был экономить.

Почему? Потому что:

• "Говори кратко" — это фильтр на выходе. Дёшево.
• "Думай кратко" — это constraint на процесс. Модель начинает тратить токены на самомониторинг: проверяет, достаточно ли она "пещерная", переформулирует, контролирует стиль на каждом шаге.

Это ключевое различие, которое многие упускают.

Для субагентов это особенно критично: если lead-агент общается с тиммейтами в caveman-стиле, контекст тиммейта получает деградированный ввод — фрагменты без артиклей, без связок, без нюансов. Это уже не вопрос стиля вывода — это вопрос качества входного контекста для следующего агента в цепочке.

Что всё это значит

Caveman решает не ту проблему

Реальная проблема — модели болтливы. Решение — краткость. Caveman добавляет поверх краткости персону, словарь, стилистику — и всё это overhead.

Всякие обёртки в виде CAVEMAN только усложняют модель, потому что ей нужно перепроверять себя: ведёт ли она себя как CAVEMAN или нет. В её претрейнинговом датасете не было фрейминга на CAVEMAN-поведение — это нестандартная для модели роль. Каждый токен, потраченный на соответствие персоне, — это токен, не потраченный на решение вашей задачи.

Если бы моя задача была в экономии токенов, я бы просто написал:

"Be concise. Lead with action, not reasoning. Skip filler. No preamble. Code comments stay normal."

Чистая инструкция "be concise" даёт 80% выгоды Caveman при 0% рисков.

Шире, чем Caveman

Этот эксперимент — частный случай более широкой темы. Мы привыкли думать о промпте в двух измерениях: что сказать модели и как структурировать. Но есть третье измерение — в какой когнитивной рамке говорить с моделью:

Каждый из этих стилей — не косметика. Это конфигурация вычислительного графа модели.

Anthropic обнаружила внутри Claude 171 эмоциональное представление — внутренние паттерны, которые каузально влияют на поведение модели. Контекст, который мы подаём, не просто информирует — он активирует внутренние состояния, меняющие стратегию рассуждения.

Свежая работа "Brevity Constraints Reverse Performance Hierarchies" (март 2026) показала, что ограничение больших моделей краткостью улучшает точность на 26 п.п. — потому что многословие вносит ошибки через переусложнение. Но "будь краток" и "будь пещерным человеком" — это принципиально разные инструкции.

Итого

Это уже не пласт инженерии. Это психология моделей.

Изучение Soul-документов — документов характера, встроенных в веса модели при обучении. Активация эмоциональных векторов. Понимание "личности" каждой модели — всего, что было заложено на претрейнинге.

Anthropic определяет Context Engineering как поиск "наименьшего набора высокосигнальных токенов, максимизирующих вероятность желаемого результата". Но "высокосигнальный" — это не только про информацию. Это про активацию правильных внутренних представлений.

Каждый стилистический выбор в промпте — это архитектурное решение. Относитесь к нему соответственно.

Язык определяет мышление. Для LLM — буквально.

Методология

Короткие фрагменты raw-выводов по каждой задаче. Полные прогоны остались в source-пакете и в публикацию не попали.

=== VERSION A: Our Caveman ===
from __future__ import annotations

import argparse
import hashlib
import os
import sys
from collections import Counter, defaultdict
from dataclasses import dataclass
from pathlib import Path
from typing import DefaultDict, List, Optional, Tuple


CHUNK_SIZE = 1024 * 1024
NO_EXTENSION_LABEL = "[no extension]"


@dataclass
class FileRecord:
    path: Path
    display_path: str
    size: int
    extension: str


@dataclass
class AnalysisResult:
    root: Path
    files: List[FileRecord]
    extension_counts: Counter
    total_size: int
    duplicates: List[Tuple[str, List[FileRecord]]]
    warnings: List[str]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Analyze a directory and print a formatted report."
    )
    parser.add_argument(
        "directory",
        nargs="?",
        default=".",
        help="Directory to analyze. Defaults to the current directory.",
    )
    return parser.parse_args()

=== VERSION C: Explanatory ===
#!/usr/bin/env python3
"""Analyze a directory and print a formatted report."""

from __future__ import annotations

import argparse
import hashlib
import os
import sys
from collections import Counter, defaultdict
from dataclasses import dataclass, field
from datetime import datetime
from pathlib import Path
from typing import Iterable


CHUNK_SIZE = 1024 * 1024
NO_EXTENSION_LABEL = "[no extension]"


@dataclass
class FileRecord:
    path: str
    relative_path: str
    size: int
    extension: str


@dataclass
class DuplicateGroup:
    digest: str
    files: list[FileRecord] = field(default_factory=list)


@dataclass
class AnalysisResult:
    root: str
    extension_counts: Counter[str]
    total_size: int
    files: list[FileRecord]
    duplicates: list[DuplicateGroup]
    warnings: list[str]


def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Analyze a directory and print file counts, size, largest files, and duplicates."

=== VERSION C: Explanatory ===
from __future__ import annotations

import argparse
import ast
import html
import json
import re
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Union


class TemplateError(Exception):
    """Base class for template engine failures."""


class TemplateSyntaxError(TemplateError):
    def __init__(self, message: str, template_name: str, line: int) -> None:
        self.message = message
        self.template_name = template_name
        self.line = line
        super().__init__(self.__str__())

    def __str__(self) -> str:
        return f"{self.template_name}:{self.line}: {self.message}"


class TemplateRenderError(TemplateError):
    def __init__(self, message: str, template_name: str, line: int) -> None:
        self.message = message
        self.template_name = template_name
        self.line = line
        super().__init__(self.__str__())

    def __str__(self) -> str:
        return f"{self.template_name}:{self.line}: {self.message}"


class TemplateIOError(TemplateError):
    pass


class SafeString(str):
    """Marker type used to skip HTML escaping on final output."""


@dataclass(frozen=True)
class Token:

Источники

1. Caveman — Claude Code skill

   Исходный навык, из которого вырос эксперимент. Полезно посмотреть README и обещания про скорость, читаемость и экономию токенов

2. Caveman SKILL.md

   Тот самый слой инструкций: “Respond terse like smart caveman”. Важно как пример Output Style, который меняет генерацию с первого токена

3. Effective Context Engineering for AI Agents

   Базовый текст Anthropic про context engineering и “наименьший набор высокосигнальных токенов”. Помогает увидеть Output Style как часть управления контекстом

4. Context Rot: How Increasing Input Tokens Impacts LLM Performance

   Исследование Chroma про деградацию качества при росте контекста. Хороший фон к тезису, что больше текста не всегда означает лучшее поведение модели

5. Emotion Concepts and their Function in a Large Language Model

   Mechanistic interpretability-работа про внутренние эмоциональные представления Claude. Нужна для мысли, что контекст активирует состояния, а не просто добавляет факты

6. Brevity Constraints Reverse Performance Hierarchies

   Работа о том, как ограничения краткости меняют качество ответов больших моделей. Важное различие: “будь краток” и “будь пещерным человеком” не одно и то же

7. Claude 4.5 Opus' Soul Document

   Разбор “документа характера”, встроенного в обучение модели. Полезен как пример неявного контекста, который взаимодействует с явными инструкциями