# Why mixed registers fail

Web page: https://academy.memberpress.ai/courses/great-minds-constellation/l6/

Lesson 6 of 16 in [The Great Minds Constellation](https://academy.memberpress.ai/courses/great-minds-constellation/), 14 min.

Video: https://www.youtube.com/watch?v=4hB_1YruCvI

A register is not a tone. Tone is how warm or formal you sound. A register is the full system: the vocabulary you use, the assumptions you make about what the reader already knows, the kind of evidence you reach for, and the shape of your sentences when you are thinking well.

When registers mix in a single context window, the output starts making decisions that belong to both crafts — and optimizing for neither.

**A worked example**

Ask a single Claude session to: (1) write a product description for a developer tool, and then (2) design the information architecture for the landing page that will display it.

Watch what happens to the product description. It will be shorter than it would have been in a pure writing session. It will front-load the features rather than the problem. It will read like a bullet list waiting to happen, because the model is already anticipating the IA work and shaping the prose toward scannability.

The IA work will also suffer. The information architecture will assume the prose constraints rather than questioning them. A pure IA session might challenge the section order, or decide that the product description should not appear at all above the fold. The mixed session makes a packaging decision and then writes toward it.

Neither output is terrible. Both outputs are compromised.

**The designer who codes**

A persona that switches between visual design and systems programming produces mediocre design and mediocre code — not because the person (or model) lacks both skills, but because the context required for each is incompatible. Good visual design requires holding the user's perceptual experience as the primary constraint. Good systems programming requires holding correctness and performance as the primary constraints. A context window cannot hold both without one dominating.

The way out is a well-defined interface. The designer passes a wireframe. The engineer builds to it. Neither crosses into the other's register. The wireframe is the negotiated boundary.

**When the register shift is acceptable**

At the orchestration layer. Phil Jackson does not stay in a single craft register — he moves between them because his job is to understand all of them well enough to coordinate them. The orchestrator's register is meta: it talks about crafts rather than within them.

The key word is meta. The orchestrator says "the writer needs to tighten the hook before the publisher makes a format decision." The orchestrator does not tighten the hook. The orchestrator does not make the format decision. It names the sequence.

**If you get stuck**

If a session starts making decisions that belong to a different plugin — a writing session that starts specifying fonts, a design session that starts writing headline copy — stop the session. The context has drifted. Extract the artifact produced so far, open the correct plugin, and continue from there.

If the same drift keeps happening, the problem is in the brief. The brief you are passing to the plugin includes constraints or signals from the other craft. Strip them out. The brief should contain only what this craft needs to know.

**Cross-reference**

Lesson 9 (Practice — audit your plugin boundaries) is the hands-on version of this lesson. It walks you through reading your own existing prompts for register contamination.

**Deliverable**

Take one prompt you use regularly that asks Claude to do two things. Identify the two registers. Write the one-sentence interface — what the first craft produces, what the second craft receives — and split the prompt accordingly.

**Further reading**

- ["The Architecture Is Not Neutral"](https://sethshoultes.com/blog/pipeline-transmits-the-operators-concern.html) — what the named personas in a pipeline are actually doing when they "vote": transmitting the operator's theory of value, not running an autonomous process.
- ["The Orchestrator Does Not Write"](https://sethshoultes.com/blog/the-orchestrator-does-not-write.html) — why a session that holds two registers at once produces hollow prose; the orchestrator dispatches, doesn't pattern-match.

## Try these prompts

- Take one prompt you use regularly that asks Claude to do two things. Identify the two registers. Write the one-sentence interface that separates them and split the prompt into two.
- Describe what happens to a product description written in a session that is also planning the landing page information architecture. Name the specific compromise in each output.
- A design session starts writing headline copy. Name the signal that tells you the context has drifted, and write the one action to take before continuing.

Next: [Persona files are written in craft register](https://academy.memberpress.ai/courses/great-minds-constellation/l7/)