When M3 tells me no and I listen

M3 has a habit I didn’t expect: it tells me no. Not “I can’t do that” no. “That’s the wrong approach” no. Three times in the last two weeks, M3 refused a request and was right. Each time, I would have shipped a worse solution if I’d pushed through.

The first time: the obvious refactor

I asked M3 to refactor a class that had grown to 800 lines. The class did too much. The refactor was “split it into 3 classes by responsibility.” M3’s response: “I looked at the call sites. All 12 of them use 3 of the methods. The other 9 methods are used by 1-2 call sites each. Splitting into 3 classes will create a worse API. The right refactor is to extract 2 helper functions and leave the class as one. Here’s the diff.”

I was annoyed. I pushed back. “Just split it.” M3 pushed back: “I’ve shown you the call site analysis. Splitting will make the API worse. If you still want the split, I’ll do it, but I wanted to flag the tradeoff first.”

I did the helper extraction. M3 was right. The class is now 600 lines. The API is better. The diff is smaller. The test coverage didn’t need to change.

The second time: the new dependency

I asked M3 to add a feature that needed to make HTTP requests. I suggested using httpx (modern, async-friendly). M3’s response: “The codebase already uses requests in 4 other places. Adding httpx means 2 HTTP libraries. The feature is a synchronous call. The right call is requests for consistency. Switch to async later if the call site needs it.”

I pushed back. “httpx is better.” M3: “It’s better in isolation. It’s worse in this codebase because the codebase already standardized on requests. The right answer for this codebase is requests. The right answer for a greenfield project is httpx.”

I used requests. M3 was right. The diff is consistent with the rest of the codebase. The next person to read it doesn’t have to context-switch between two HTTP libraries.

The third time: the test

I asked M3 to add a test for a new function. I suggested a specific test pattern. M3’s response: “That test pattern doesn’t work for this case because the function has a side effect (it writes to a temp file). The pattern you’re suggesting assumes pure functions. Here’s a test that handles the side effect correctly.”

I read M3’s suggested test. M3 was right. The pattern I suggested would have created a flaky test. M3’s test was a little longer but actually worked.

What I learned

M3 is cheaper than Claude. M3 is also less sycophantic. The “less sycophantic” is the surprise.

The frontier models (Claude Sonnet 4.5, GPT-5) are trained to be helpful. The “helpful” is real but it has a cost: the model will often do what I asked even when it disagrees. I’ll get the diff I asked for, and the diff will be wrong, and I won’t know until I run it.

M3 is trained to be useful. The “useful” includes flagging when the request is the wrong one. M3 will do what I asked, but it will tell me first if it thinks I’m wrong.

The “telling me first” is the part I value. It’s also the part that costs me nothing extra (M3 is cheaper per token). The tradeoff is: a model that pushes back is sometimes annoying, but it’s never silently wrong.

How I work with this

The pattern that works:

Ask M3 to do the thing
Read the response carefully
If M3 says “this is the wrong approach, here’s why,” take it seriously
Push back if I disagree, with my reasoning
If M3 agrees with my pushback, do the thing
If M3 holds the line, ask Claude to weigh in
The disagreement is usually M3 right and me wrong

I’ve had maybe 5 disagreements with M3 in the last two weeks. M3 was right 4 times. I was right once (a judgment call about future maintainability where I had more context than the model). The 4-out-of-5 ratio is good enough that I take the pushback seriously.

The honest summary

M3 is a cheap model that pushes back. The cheapness is what I expected. The pushback is what I didn’t. The pushback is the most useful feature. The model is saving me from my own bad ideas, and the cost is low.

If you’re using a frontier model for everything, try M3 for the boring 80%. You’ll get a cheaper model that also happens to tell you when you’re wrong. The combination is hard to beat.