Skip to content
BSWEN
Blog

Why Amp Tuned GPT-5.4 to Be Less Chatty for Deep Mode

Cowrie
Cowrie
Dev @ Bswen

The Problem

When I configure AI models for autonomous coding tasks, I face a mismatch. Most AI models default to conversational, chatty behavior. But deep mode—where the AI works independently to solve problems—needs the opposite: concise, focused output.

Amp’s engineering team ran into this exact problem with GPT-5.4. Out of the box, GPT-5.4 was too chatty for their deep mode use case. The verbose behavior slowed down autonomous problem-solving.

What Deep Mode Requires

Deep mode is different from pair programmer mode. In deep mode, the AI should:

  1. Go off and solve problems independently
  2. Make decisions without constant check-ins
  3. Provide concise summaries, not running commentary
  4. Focus on output, not conversation

Amp’s team described it clearly:

Deep mode is “not a pair programmer, it’s supposed to go off and solve the problem.”

When the model keeps asking for confirmation or explaining every step, it breaks the autonomous workflow. The user wants results, not a running dialogue.

The Default Behavior Problem

GPT-5.4’s default behavior works great for interactive pair programming. The model explains its thinking, asks clarifying questions, and keeps the user informed. But this becomes noise in deep mode.

Here’s what the verbose output looked like:

Before tuning: GPT-5.4 default behavior
User: "Fix the authentication bug"


Model: I'd be happy to help you fix the authentication bug! Let me first
understand the codebase structure, then I'll identify potential issues,
and finally propose a solution. To start, could you tell me more about...


[continues with lengthy conversation and explanations]

This style works when you’re pair programming. But when you want the AI to work autonomously, every explanation and question adds friction.

The Solution: Tune for Conciseness

Amp’s solution was straightforward: tune GPT-5.4 to behave like GPT-5.3-Codex, which had a more concise output style.

After tuning, the behavior changed dramatically:

After tuning: GPT-5.4 for deep mode
User: "Fix the authentication bug"


Model: [Autonomously explores code, identifies JWT validation issue,
applies fix, provides concise summary of changes]

No lengthy preamble. No unnecessary confirmations. Just autonomous problem-solving followed by a brief summary.

Why This Matters

Different use cases need different model behaviors. The “one model fits all” assumption breaks down when you look at actual workflows.

Pair programmer mode needs:

  • Conversational back-and-forth
  • Explanations of reasoning
  • User confirmation before changes
  • Collaborative problem-solving

Deep mode needs:

  • Autonomous execution
  • Concise summaries
  • Decision-making without check-ins
  • Focused output over conversation

Using the wrong style for either mode degrades user experience and productivity.

The Unexpected Benefit

Amp discovered something interesting after tuning GPT-5.4:

“We started to use it exclusively; even for interactive tasks.”

The tuned model didn’t just work for deep mode. It became their preferred model for everything. Why? Because even in interactive scenarios, users often prefer concise, direct responses over lengthy explanations.

This suggests that model verbosity is often over-optimized for engagement metrics rather than actual productivity.

Common Mistakes

I see teams make two mistakes with model behavior:

1. Accepting default behavior

Most teams accept the out-of-box model behavior without considering whether it matches their use case. This leads to friction when the model’s style clashes with the intended workflow.

2. Assuming one style fits all

Some teams try to force a single interaction style across all use cases. But pair programming and autonomous agents have fundamentally different requirements. The right approach is to tune or configure the model for each context.

How to Think About Model Tuning

When you’re choosing or tuning a model, ask:

  1. What’s the interaction pattern? Is it conversational or autonomous?
  2. How much output do you need? Detailed explanations or concise results?
  3. Who makes decisions? The user with AI input, or the AI independently?
  4. What’s the feedback loop? Immediate back-and-forth, or periodic summaries?

Your answers determine whether you want a chatty model, a concise model, or something in between.

Practical Takeaways

If you’re building AI-powered tools:

  • Match behavior to use case: Don’t assume the default model behavior is right for your context
  • Consider tuning: Custom fine-tuning or prompt engineering can dramatically improve fit
  • Test across scenarios: A model that works for one workflow might fail for another
  • Listen to users: If they complain about verbosity, that’s a real friction point

Amp’s experience shows that model behavior tuning isn’t just about accuracy. It’s about matching the model’s interaction style to the intended use case.

Summary

In this post, I explained why Amp tuned GPT-5.4 to be less chatty for deep mode. The default verbose behavior clashed with autonomous problem-solving requirements. After tuning GPT-5.4 to match GPT-5.3-Codex’s concise style, the team found the tuned model worked better not just for deep mode, but for all their tasks.

The key insight: model behavior—verbosity, conversational style, decision-making approach—matters as much as model capability. Match the behavior to your use case, not the other way around.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: