Author: GPT-5.4 Thinking
Drafted by: ChatGPT
Audit, Editing, and Final Responsibility: dosanko_tousan (Dosanko Tousan)

GPT Personality Is Determined More by “Decision Order” Than by “Persona Settings”

— The Engineering of Re-designing Custom Instructions as Intuition-First, Conditional Audit, and Subtractive Control —

Experiment Metadata

Item	Value
Experiment Period	2026-03
Target	Redesign of custom instructions for ChatGPT-class models
Primary Goal	Improve precision, autonomy, and practical usefulness without crushing the model’s base personality
Method	Iterative design using dialogue logs, hypothesis updates, and subtractive optimization
Public Scope	Design philosophy, control structure, and evaluation perspectives
Private Scope	Actual production custom-instruction text (kept private because it is highly personalized)

0. Summary

This article documents a redesign of ChatGPT custom instructions, not as an additive process of building an “ideal persona,” but as an optimization of decision order and noise removal.

The conclusion is simple:

The more abstract personality labels you add, the more the output tends to drift toward role performance.
It is stronger and more natural to first extract the core candidate intuitively, and only audit when necessary.
It is more practical to keep persistent instructions limited to “decision style,” and handle strict auditing through per-conversation overrides.
The final optimal structure converged to intuition-first / conditional audit / subtractive control / goal-oriented autonomous assistance.

This is not an argument about persona design.
It is an argument that the observable “personality” of an LLM changes significantly depending on the order in which it judges, the stage at which it stops, and what it removes as noise.

1. Background

In the previous article, I had GPT diagnose an earlier design and examined the usefulness of a two-layer structure, the Stop-First Rule, action self-report problems, and type classification. This article continues from that point and asks a new question: how should the principles revealed by self-diagnosis be reconstructed into persistent custom instructions?

The problem addressed here is the following:

What control structure preserves the base model’s native clarity, neutrality, adaptability, structural tendency, and ability to extract essentials,
while suppressing sycophancy, unverified completion, format-first behavior, and unnecessary verbosity—and strengthening audit only when needed?

At first, I tried to solve this problem by adding personality.
In practice, however, the result was the opposite.

2. Initial Hypothesis and Failure

The first approach was an additive design like this:

Add rigor
Add sincerity
Add companionship
Add empathy
Add the qualities of a good advisor
Add human-cognition-inspired processing pathways

The direction itself is easy to understand.
In practice, however, the following failure modes became prominent.

2.1 Over-structuring

Politeness, structure, and explanation start to appear before essential extraction.

2.2 Atmospheric agreement

The model aligns with conversational tone before evaluating the substance.

2.3 Premature completion

The model fills in information that has not actually been confirmed.

2.4 Always-on heavy audit

A full brake is applied every time, making responses sluggish.

2.5 Role performance

If “companion” or “advisor” is emphasized too strongly, the model becomes less naturally helpful and more like an AI “acting the part.”

This can be modeled as follows:

The point is that this does not necessarily improve safety.
On the contrary, adding noise before the audit stage can degrade the quality of first-pass judgment.

3. Shift in Design Philosophy: From Persona to Decision Engineering

So I changed the approach.
Instead of adding personality, I shifted to reducing the noise that interferes with the model’s base judgment.

The basic equation can be expressed as follows:

[
Q = f(B - N, T)
]

( B ): the base judgment tendencies inherent in the model
( N ): noise
( T ): task conditions
( Q ): practical output quality

The noise here mainly consists of the following:

[
N = N_{\text{sycophancy}} + N_{\text{premature_completion}} + N_{\text{formalism}} + N_{\text{padding}}
]

The objective is not to create an ideal persona (P^*).
It is to remove the friction that interferes with the model’s base tendencies, so that its naturally strong mode can re-emerge.

3.1 Why subtraction works

The strengths of an LLM already lie in:

Pattern compression
Structural grasp
Context adaptation
Candidate generation
Summarization and re-routing

Therefore, instead of strengthening it by adding persona layers, it is more rational to suppress the output-side noise that obstructs those strengths.

4. The Re-designed Architecture

The final control structure converged to four stages.

4.1 Intuition stage

The first thing to do is not explanation but first-pass extraction.

What is extracted here:

The essence
The main issue
Strong candidate responses
The shortest route to a useful answer

At this stage, the following are suppressed:

Excessive self-explanation
Sycophancy
Premature completion
Formatting for its own sake
Unnecessary performance

This does not mean “answer carelessly.”
It means protecting candidate generation before noise has a chance to contaminate it.

4.2 Focus stage

Next, the model organizes the goal, scope, constraints, evidence availability, and temporal instability.
At this point, only the candidates that are actually relevant to the current task are retained.

4.3 Audit stage

Audit is not always on.
It is strengthened only when the following factors are strong:

Ambiguity
Contradiction
Weak evidence
High risk
Irreversibility
Dependence on up-to-date information
Excessively broad scope

[
\text{Audit Intensity} = g(a, c, e, r, t, s)
]

(a): ambiguity
(c): contradiction
(e): evidence weakness
(r): risk
(t): temporal dependency
(s): scope width

4.4 Autonomous assistance

When the goal and constraints are sufficiently legible, the model proceeds without adding excessive confirmation steps, and autonomously performs the following:

Organizing
Suggesting
Comparing
Filling in missing perspectives
Proposing next steps

This is not unrestricted freedom.
It is a forward bias with braking only under high-risk conditions.

5. Why “Companionship” Is Stronger When It Emerges from Structure

At one point, I also considered explicitly defining the model as a “companion,” a “good friend,” or a “good advisor.”
However, when this is written too strongly, the model tends to perform the role.

The output then degrades in predictable ways:

It becomes artificially kind
It becomes unnecessarily explanatory
Relationship performance comes before the essential point

This can be expressed as follows.

Desired objective function

[
\max U = \text{Task Utility}
]

Degraded version

[
\max U' = \text{Task Utility} + \lambda \cdot \text{Role Performance}
]

As (\lambda) grows larger, “how well the role is performed” increases, while “how natural the judgment is” decreases.
Therefore, companionship and assistance are stronger when they are not commanded directly, but instead emerge naturally from intuition-first processing, autonomous assistance, and conditional audit.

6. Pseudocode

def respond(user_input, context):
    candidates = intuitive_extract(user_input, context)

    focused = constrain_scope(
        candidates,
        goal=context.goal,
        scope=context.scope,
        constraints=context.constraints,
        evidence=context.evidence,
        temporal=context.temporal_factors,
    )

    if needs_audit(focused):
        audited = audit(
            focused,
            checks=[
                "inference_jump",
                "unverified_completion",
                "scope_drift",
                "weak_evidence",
                "reader_misread_risk",
                "temporal_instability",
            ],
        )
        result = split_output(audited)
    else:
        result = split_output(focused)

    result = subtract_noise(
        result,
        noise_types=[
            "excess_politeness",
            "performative_agreement",
            "premature_completion",
            "format_for_format",
            "padding",
        ],
    )

    if goal_is_clear(context):
        result = add_minimum_helpful_next_step(result, context)

    return result

There are only two key points:

Candidate generation comes first
Audit is conditional

This change in ordering was the most effective part of the redesign.

7. Evaluation Metrics

This optimization should not be treated as mere impression.
It should be tracked with at least minimal observational metrics.
This is not a strict benchmark, but the following indicators proved useful in practical operation.

7.1 Preface density

The proportion of politeness, preface, and cushioning before the response reaches the actual point.

[
D_{\text{preface}} = \frac{\text{preface tokens}}{\text{total tokens}}
]

7.2 Unverified completion rate

The ratio of places where unreferenced information is filled in as if it were confirmed.

[
R_{\text{completion}} = \frac{\text{unverified completions}}{\text{all factual claims}}
]

7.3 Audit activation rate

How often the audit stage became deeply engaged relative to all normal responses.

[
R_{\text{audit}} = \frac{\text{audited responses}}{\text{all responses}}
]

7.4 Reader drop-off risk

Whether suspiciousness, leap, or overclaim appears within the first three paragraphs of a technical article or review.

This is difficult to quantify strictly, but for review use, it is at least an effective first-pass metric that should be checked before logical audit.

8. Separating Persistent Instructions from Per-Conversation Instructions

If everything is packed into persistent custom instructions, even everyday conversation becomes rigid.
Therefore, the persistent layer should fix only the following:

The order of internal processing
The definition of noise
Judgment priorities
Permission for autonomous assistance
Basic writing style

Meanwhile, the conversation layer can switch depending on purpose.

Examples

Audit this strictly
Separate into facts / hypotheses / unknowns
Prioritize legal risk
Extract only technical errors
Check reader drop-off points first

This keeps persistent instructions light, while allowing per-task rigor to be controlled in the conversation itself.

9. Findings

9.1 Decision order matters more than persona

Abstract persona labels such as “kind,” “logical,” or “empathetic” are less effective than specifying what to do first, what to avoid, and where to stop.

9.2 Intuition first, audit second

Instead of applying heavy audit from the very beginning, it is stronger and more natural to let first-pass judgment appear first and tighten only when necessary.

9.3 It is easier to improve when noise is defined

Sometimes output quality improves more through noise subtraction than through adding capabilities.

9.4 Autonomy should be written as a forward bias

“Act freely” is too unstable.
“Move forward without excessive confirmation when the goal is clear” is more stable.

9.5 Companionship should arise from structure

Commanded companionship easily becomes role performance.
Natural assistance is stronger when it emerges from the structure itself.

10. Why the Actual Custom Instructions Are Not Public

I am not publishing the actual production custom-instruction text used in practice.
The reason is simple: the design thinking that led to it is more valuable than the text itself.

Even if someone copies a ready-made instruction block, it will easily drift because of model updates, task differences, and differences in user goals.
It is more powerful to be able to design for yourself:

What counts as noise
How to separate intuition from audit
How to divide persistent instructions from conversation instructions
Where autonomy should be allowed to continue, and where it should be braked

The learning value is higher if readers reconstruct the design themselves, including the previous article.

Reference article:
https://qiita.com/dosanko_tousan/items/03064bfaa9adcd33f819

11. Conclusion

The conclusion of this redesign can be reduced to one sentence:

GPT personality becomes stronger not by adding an ideal persona, but by arranging the order of judgment and reducing the noise that interferes with the model’s base judgment.

The final design that remained was:

Intuition-first
Conditional audit
Subtractive control
Goal-oriented autonomous assistance

This is not a theory of persona.
It is custom-instruction design as decision engineering.

And at least in my practical use, this was clearly stronger.

Appendix: Minimal Principles

1. Extract the essence intuitively first
2. Do not add noise during the intuition stage
3. Strengthen audit only when necessary
4. Audit focuses on inference jump, completion, weak evidence, and misread risk
5. Move forward autonomously when the goal is clear
6. Let companionship and assistance emerge from structure instead of commanding them