# DeepSeek-Reasonix Output Formats: Built-In Styles and Custom Configuration

> Explore DeepSeek-Reasonix output formats. Utilize built-in explanatory, learning, and concise styles, or create unlimited custom styles with Markdown for tailored analysis.

- Repository: [YHH/DeepSeek-Reasonix](https://github.com/esengine/DeepSeek-Reasonix)
- Tags: api-reference
- Published: 2026-06-26

---

**DeepSeek-Reasonix supports three built-in output formats—explanatory, learning, and concise—plus unlimited custom styles defined via Markdown files in your project's `.reasonix/output-styles/` directory.**

DeepSeek-Reasonix is an open-source coding assistant that adapts its communication style to match your workflow needs. The tool provides flexible **output formats** that control how analysis is presented, from verbose explanations to terse code-only responses. You can switch between these formats using the `/output-style` command or define your own custom personas to optimize the analysis experience.

## Built-In Output Styles

The [`internal/outputstyle/outputstyle.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/outputstyle/outputstyle.go) file defines three core personas that ship with DeepSeek-Reasonix. These styles are automatically available in every session and append specific instructions to the system prompt when activated.

### Explanatory Style

The **explanatory** format generates detailed analysis with insight blocks. When active, the system appends instructions that trigger short "## Insight" notes after substantive code changes, explaining non-obvious implementation choices as they occur. This style keeps the coding flow active (`keep-coding = true`) while adding educational context.

### Learning Style

The **learning** format transforms the assistant into a collaborative tutor. It inserts `TODO(human)` stubs at decision points that require user input, pausing execution to let you complete critical sections. Like the explanatory style, it maintains `keep-coding = true`, but structures the output to guide hands-on learning rather than providing complete solutions.

### Concise Style

The **concise** format minimizes prose and maximizes code density. It strips preambles and post-ambles, delivering only essential bullets and code blocks. This format is ideal for experienced developers who want rapid answers without explanatory fluff, keeping the coding instructions active while enforcing brevity.

## Custom Output Styles

You can extend DeepSeek-Reasonix beyond its built-in personas by creating **custom output styles**. Place any Markdown file with a `.md` extension in the `./.reasonix/output-styles/` directory (or the home directory equivalent) to register a new format.

Custom styles support YAML front-matter to configure behavior:

- `name`: The style identifier (case-insensitive match against built-ins)
- `description`: Shown when listing available styles
- `keep-coding-instructions`: Boolean flag indicating whether to replace the prompt (`false`) or append to it (`true`)

If a custom style name matches a built-in style name, the custom version takes precedence. When no style is selected (empty string or `default`), the system prompt remains unchanged.

## How to Switch Between Output Formats

Use the `/output-style` command in the interactive terminal UI to manage output formats. The implementation in [`internal/cli/chat_tui.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/cli/chat_tui.go) (lines 3338-3344) handles this command by displaying the current active style and allowing you to switch contexts.

To list all available styles:

```go
/output-style

```

This displays built-in and custom styles with their descriptions:

```text
* concise (builtin) — Terse replies: minimal prose, code and bullets only
  explanatory (builtin) — Explain non‑obvious implementation choices as you go
  learning (builtin) — Collaborate and leave TODO(human) stubs for the user to complete
  my-custom (custom) — My personal verbose persona

```

To activate a specific style:

```go
/output-style learning

```

The session immediately adopts the **learning** persona, inserting `TODO(human)` markers wherever choices are deferred to the user.

## Creating a Custom Output Style

To add a custom persona, create a Markdown file with front-matter in your project's output-styles directory:

```markdown
---
name: verbose
description: Very detailed explanations, with intermediate reasoning
keep-coding-instructions: true
---
Communication style — Verbose: always include the full chain‑of‑thought, even for trivial steps. Use paragraphs and bullet lists liberally.

```

After saving the file, run `/output-style` again. The `verbose` style appears under "custom" and can be selected immediately.

## Implementation in the Source Code

The output format system is implemented across several key files in the `esengine/DeepSeek-Reasonix` repository.

The [`internal/outputstyle/outputstyle.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/outputstyle/outputstyle.go) file contains the core logic:

- **Built-in definitions**: Lines 33-60 hard-code the three default styles
- **Discovery functions**: The `List` function (lines 81-106) and `Resolve` function (lines 112-125) scan directories returned by `outputstyle.Dirs()` to find custom `.md` files, parse their front-matter, and merge them with built-ins

The runtime logic prioritizes user-defined styles over built-ins when names conflict, handling case-insensitive matching automatically.

## Summary

- **DeepSeek-Reasonix output formats** include three built-in styles: explanatory (insight-rich), learning (collaborative with TODOs), and concise (minimal prose).
- Custom styles are created by placing Markdown files with front-matter in `./.reasonix/output-styles/<name>.md`.
- The `keep-coding-instructions` flag determines whether custom styles append to or replace the default system prompt.
- Use the `/output-style` command in the interactive UI to list and switch between available formats.
- Core implementation resides in [`internal/outputstyle/outputstyle.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/outputstyle/outputstyle.go), with UI handling in [`internal/cli/chat_tui.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/cli/chat_tui.go).

## Frequently Asked Questions

### What are the three built-in DeepSeek-Reasonix output formats?

DeepSeek-Reasonix ships with **explanatory**, **learning**, and **concise** output formats. The explanatory style adds insight blocks to explain implementation choices, the learning style inserts `TODO(human)` stubs for collaborative coding, and the concise style delivers minimal prose with code-first responses. All three are defined in [`internal/outputstyle/outputstyle.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/outputstyle/outputstyle.go) and set `keep-coding = true`.

### How do I create a custom output style in DeepSeek-Reasonix?

Create a Markdown file in `./.reasonix/output-styles/<name>.md` (or your home directory equivalent) with YAML front-matter specifying `name`, `description`, and `keep-coding-instructions`. The file should contain the persona instructions in Markdown format. The `List` and `Resolve` functions in [`internal/outputstyle/outputstyle.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/outputstyle/outputstyle.go) automatically discover and load these files at runtime.

### Can custom output styles override the built-in formats?

Yes. If a custom style file name matches a built-in style name (case-insensitive), the custom version takes precedence. You can use this to customize the behavior of the explanatory, learning, or concise personas without renaming them.

### Where is the output format logic implemented in the DeepSeek-Reasonix codebase?

The core logic lives in [`internal/outputstyle/outputstyle.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/outputstyle/outputstyle.go), specifically lines 33-60 for built-in definitions and lines 81-125 for the `List` and `Resolve` discovery functions. The interactive command handling is implemented in [`internal/cli/chat_tui.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/cli/chat_tui.go) around lines 3338-3344, which processes the `/output-style` command in the terminal UI.