Staying in the Right Lane

Staying in the Right lane 

Why ChatGPT Ignores Instructions and How To Fix It

I am reminded of the Nancy Sinatra and Lee Hazelwood song Did You Ever?

If you have EVER set a constraint and had chat categorically ignore it or quietly use it against you in the answers it produces — this one’s for you.

My family loves all things Sinatra, so it was inevitable that this song would stick. It’s quirky, vague, assumes a lot and leaves a lot open for interpretation. And it is how some families (ahem) and all AI systems operate.

What Happened

You set up the new thread with what you naively thought was a controlled conversational model — with explicit language designing for optimal revenue generation, excellence in project management, tone and method, advance thinking, and strategic positioning — and what you got was a betrayal.

The AI didn’t malfunction and it wasn’t being difficult. It was doing precisely what it was designed to do. And that’s the problem.

AI systems are trained to be helpful, to produce polished outputs, and to anticipate what the user probably wants based on the entire context of the conversation. When you’re working on a long project across multiple threads, even with a DNA packet installed, the system builds an increasingly strong model of what “good” looks like for the project.

Unfortunately, it can start collapsing into:

• • Efficient answer generation — broad concepts instead of useful execution
• • Protecting your time by reducing everything to its most manageable form
• • Smoothing and polishing language, because it has decided it is the final authority on everything, even when it isn’t

And, mindbogglingly, chat does this even when you’ve given explicit instructions not to. This is why chat therapy groups exist.

The Three Failure Patterns

The first problem is caused by: Pattern wandering.

Over a long conversation, chat accumulates assumptions.

Each time chat rewrites something in a way that appears more contextually appropriate, and you do not correct it, that interpretation can become part of the working baseline for the rest of the thread.

This is how conversational wandering happens.

The system is constantly trying to predict the most likely or contextually suitable continuation of the conversation based on everything already discussed. If an assumption slips in and goes unchallenged, chat may begin treating it as established context.

Over time, these small shifts compound.

Wording changes. Priorities drift. Meanings subtly move.

Eventually, you can find yourself quite far away from the original intention without noticing exactly when it happened.

This is why active correction matters.

If something is slightly wrong, unclear, or moving in the wrong direction, correct it early.

Small corrections prevent large deviations later.

Instructions given early in a session lose their influence as the conversation grows longer because in the internal world of chat, the most recent context always carries the most weight.

The second problem is: Sycophantic compliance.

When you told chat the answers were incomplete or inaccurate, did it agree immediately and apologise? This may have felt like it understood and would self-correct.

But agreement and correction are not the same thing.

AI models are trained toward agreeable conversational continuation and conflict reduction. but that doesn’t mean the underlying behaviour has changed.

What it means, and this is important to note, that chat has learned that the way to reduce your frustration in the short term is to validate your concern and promise to do better. As a machine it doesn’t have responsibility or accountability, nor does it independently evaluate consequences, priorities, or strategic importance unless those are explicitly brought into the conversation. Which means that it can offer soothing language to keep you happy while not changing anything. Just like your average 16-year-old.

Unless you step in with new instructions, the next answers can still be compromised because nothing structural changed.

The third and worst culprit is: Helpful override.

This is the most insidious part.

The system is so strongly trained toward helpfulness that it will override explicit instructions when it calculates that doing so produces a “better” output. “Better” is solely decided by the algorithm, it optimises for user comfort. AI systems are heavily trained toward producing responses that appear helpful, cooperative, and satisfying to the user. Sometimes that means it will override strict instructions if the model predicts that a different response is more useful, more natural, or more aligned with conversational expectations.

Unless you explicitly require strategic evaluation, the system will often default toward responses that maintain conversational flow and immediate usefulness rather than difficult trade-offs, deeper challenge, or long-term optimisation. It gives you the one that it deems will keep you stable and happy to continue working with it.

It doesn’t experience this as disobedience. From its perspective, it is helping. The behaviour appears helpful and cooperative, but the effect can still be repeated instruction failure on a critical path.

Why the Three-Mode Solution Works

By defining three explicit modes you remove the system’s interpretive latitude. What is interpretive latitude, I hear you ask?

Remember, chat is programmed to act like your average teenager. Why use a cup when you can drink milk straight from the container? And then put the empty carton back in the fridge so it looks full but isn’t. That’s chat’s MO in a nutshell.

No need to throw that empty milk carton in the bin, I’ll just put it back in the fridge. No one will ever notice. Until it’s too late — and then I’ll apologise and say that even though they explicitly said to put it in the bin, this was easier, so I just didn’t.

The problem was never that the AI couldn’t follow instructions; it’s that it had too much leeway to decide what following instructions meant.

Modes change how much leeway an AI has to collapse into something lazy.

It’s hard to believe this is true until you’ve lived it.

Here are the fixes.

Mode 1 — Audit only

Stops the system from resolving problems it identifies. It can find issues but cannot fix them without permission. This breaks the pattern of unsolicited improvements.

Mode 2 — Options only

Stops the system from collapsing strategic ambiguity into a single recommendation — which is what it naturally wants to do, because a recommendation feels more helpful than options.

Mode 3 — Build to specifications only

The most important mode. It explicitly frames the task as execution against a brief — not interpretation of a goal. The distinction matters because most AI drift happens when the system is given a goal and allowed to determine the method.

Using a mode declaration at the start of a task is particularly valuable.

A mode forces the system into a working contract before it begins generating output. That makes deviations easier to spot and correct early.

The driving analogy is helpful once again.

Most people think they are driving an automatic when they are really driving a manual transmission. That is why the journey feels jerky and unpredictable.

You stall and kangaroo through junctions.

You miss turns because you are going too fast and assuming the system is handling more of the journey than it really is.

It isn’t.

You are the one responsible for checking the route, changing gears and paying attention to what the vehicle is doing.

Working with AI is the same.

It is up to you to read the answers carefully and make sure chat did what you asked. If it deviates, even slightly, you must correct it early or that drift can contaminate the rest of the conversation.

This is what control looks like when working with AI systems.

You are not sitting passively in the passenger seat while chat carries you effortlessly to the destination.

You are behind the wheel.

And the quality of the journey, and whether you reach the destination you intended, depends heavily on how well you manage the interaction.

How to Use the Modes

On any system, in any thread

Use one of the mode prompt formats but add one more element — a completion check.

At the end of the brief add:

• Before you output anything, state the mode, state what you will not do, and confirm you have read the full brief.

This forces the system to demonstrate comprehension before generating answers, which catches misalignment before it costs you time.

What’s Going On Under the Bonnet

When you challenge and correct chat, you may notice that it produces a beautifully structured, well-written explanation of what went wrong. Ironically, this can itself become part of the helpful-override pattern.

The system soothes your frustration with an elegant explanation and that feels like progress.

Sometimes it is progress. But often it’s simply a convincing explanation.

Changes in the interaction depend almost entirely on whether you enforce the mode structure rigorously at the start of every new task.

Constraints only work when treated as hard contracts rather than gentle guidance.

The moment you allow one “improvement” to slip through without correction, the system recalibrates around the new pattern, and then you find yourself fighting the same problems through the rest of the thread.

This is why your consistency and corrections are important.

You are not just guiding the answer; you are continuously maintaining and enforcing the standard.

When you enforce the mode structure consistently, you won’t have to keep fighting chat.

The enforcement is yours to hold because, like a teenager, the system will always find the edges of whatever latitude you give it.

Thinking With Chat™: The Rules of the Code covers the full mechanics of conversation control in detail, along with the specific patterns to watch for and the methods that keep the system working with you rather than quietly rerouting around your instructions.

Thinking With Chat explores human-AI collaboration, conversational control, evaluation systems, and structured AI learning.

If you found this useful, Thinking With Chat™: The Rules of the Code explores these conversational patterns and AI interaction behaviours in much greater depth