Codex steer and Claude /btw

The most useful AI workflow tricks are usually not the flashy ones.

They are the little control surfaces. The subtle moves that keep a session from collapsing into drift, repetition, or polite nonsense.

That is how I think about steer in Codex and /btw in Claude.

Not as magic.

As small interventions that protect context.

The Real Problem Is Drift

You start with a live project, a strong idea, a repo full of history, and a decent sense of what you want.

Then an hour later the AI is still "helping," but the work has begun to slide sideways.

The code is technically fine but tonally off.

The copy is clean but generic.

The structure solves the wrong problem.

The assistant is no longer following the shape of your intent. It is following the shape of its own last few responses.

That is drift.

Most people try to solve it by dumping more instructions into the top of the conversation. Sometimes that works. Often it just makes the session heavier.

The better move is often smaller.

What steer Does In Codex

The value of steer is not that it lets you start over.

The value is that it lets you correct course without breaking momentum.

That matters when you are deep in a repo and the assistant already understands:

• the site structure
• the tone
• the branch state
• the real constraint
• the difference between what looked smart on paper and what actually feels right

At that point you do not want to throw the whole session away. You want to nudge it.

You want to say:

• less of that
• more like this
• keep the architecture, change the tone
• stop optimizing for explanation and start optimizing for signal
• preserve the vision, cut the drift

That is what steering is for.

It is the equivalent of grabbing the wheel before the car reaches the guardrail.

What /btw Does In Claude

I think of /btw as a side-channel for important nuance.

Not the main road. The aside that changes how the main road gets read.

The useful part is not the syntax. The useful part is the pattern:

you inject a clarifying aside before the model hardens around the wrong assumption.

That aside might be:

• the thing you do not want public-facing copy to imply
• the emotional truth behind the project
• the part of the design that should feel rough, not polished
• the business constraint hiding behind the aesthetic decision
• the lived context the model cannot infer from the files alone

Those little asides matter because models tend to overcommit once they think they understand the assignment.

An honest "by the way" can save twenty minutes of cleanup.

Why This Works For Writers and Idea People

If you are a pure engineer, you can often test your way back to truth.

If you are building products out of writing, design, systems, mood, and long-range intent, testing is not always enough. You also need the work to feel right.

That is where small control moves become disproportionately valuable.

A writer-builder is usually managing several things at once:

• the functional result
• the emotional tone
• the public read
• the hidden business constraint
• the long arc of the vision

That stack is exactly where drift becomes expensive.

Which is why VS Code plus Codex is such a strong combination for this kind of person.

VS Code keeps you close to the actual artifact.

Codex lets you keep reshaping the direction without losing the larger thread.

And when you move back into Claude for certain drafting or conceptual work, the little aside function matters for the same reason: it keeps the session from locking onto the wrong version of you.

The Habit That Actually Helps

The habit is simple:

When you notice drift, do not just react emotionally and start typing more words.

Name the correction precisely.

Use the smallest move that restores alignment.

That might be:

• a steer in Codex
• a quick /btw in Claude
• a short note in the repo docs
• a source-of-truth update before the next iteration starts

The point is not to look clever.

The point is to stop paying the same cleanup tax over and over.

This Is How Context Survives

People talk about context like it is a storage problem.

Sometimes it is.

But a lot of the time it is really a steering problem.

The assistant has plenty of context. It is just leaning on the wrong parts of it.

That is why these tiny moves matter.

They do not create genius.

They keep the work from wandering away from it.

Bottom Line

Big prompts are overrated.

Small corrections, used at the right moment, are often worth more.

That is the best way I know to describe the difference these moves make:

steer in Codex keeps the project on course.

/btw in Claude keeps the model honest about what the course actually is.