What to Do When Codex Enters “Policy Artisan Mode” and Refuses to Write Code

As it becomes increasingly common to delegate code fixes to AI, have you ever experienced a situation where “the strategy sounds great, but not a single line of code actually changes"?
I experienced precisely this recently.

To align with updated specifications, a large-scale refactoring affecting the entire codebase was required, so I instructed Codex to make the fixes. However, all that came back were:

  • Explanations of the strategy
  • Enumerations of points to watch out for
  • Caveats stating “it is difficult in this environment"

This state persisted, with actual files remaining completely untouched.

In this article, I refer to this state—where the AI explains correction strategies and cautions in detail, but fails to execute actual code changes or run commands—as “Policy Artisan Mode" (Houshin Shokunin Mode). I will break down what was happening and how I handled it in my environment.

*Please note that the contents described here are based solely on the results in my own environment, and the same method is not guaranteed to reproduce universally.

目次

The Situation Where the Problem Occurred

When the state I call “Policy Artisan Mode" occurred this time, the tasks instructed to Codex were as follows:

  • Modifications were necessary to match specification documents
  • The scope of changes was not partial, but affected the entire codebase
  • Large-scale refactoring, including a review of the existing structure
  • Assuming that execution of tests would be performed after modifications to verify operation

This was not merely adding a function or making a minor tweak;
it was “work that required not just thinking, but actually getting hands dirty and proceeding through verification."

Because doing it manually would take time, I decided to leave this task to Codex.
Since it had worked without issues for routine, small-scale fixes,
I had anticipated that it could handle this scale as well.

Usual Settings

For day-to-day development, I used the following settings:

  • Model: GPT-5.1-codex-mini
  • Resources: Medium

The reason was simple: saving tokens.

Even with this configuration,

  • Small-scale fixes
  • Function-level changes
  • Logic verification and assistance

It was fully practical for purposes like these, and I had felt no particular issues.

The Problem: “Policy Artisan Mode"

However, for fixes like this one, Codex’s behavior was clearly different.

  • Explanations of the fixes were extremely polite
  • The overall strategy was also logical and sound
  • Yet, it did not execute commands
  • It did not rewrite a single file

This state of “showing strategy and ideas, but not lifting a finger" is what this article calls “Policy Artisan Mode".

The important point is that this was not due to a lack of permissions.
In the terminal, the settings had been configured from the start to allow modifying actual files.

Why It Entered Policy Artisan Mode (Speculation)

This is purely speculation, but organizing the situation leads me to think the following:

  • The scale of the modification was large
  • Processing is heavy when including test execution
  • The model is the lightweight version (mini)
  • Resources are also restricted to Medium

Under these conditions, Codex may have concluded:

“There is a high probability I cannot finish this completely in this environment."
“It is safer to stop at presenting a strategy rather than touching it halfway."

And thus gave up on actual code updates.

Rather than a bug, this behavior felt closer to an overly cautious self-judgment.

Attempted Solution: Changing Model and Resource Settings

Therefore, I changed the settings as follows:

  • Model: GPT-5.2 (GPT-5.2-Codex or similar might be better)
  • Resources: High

Once I did this, the behavior changed completely.

  • Started making modifications step-by-step
  • Actually rewrote the files
  • Executed commands and proceeded to testing

The work that had previously stalled began moving forward normally.

What Can and Cannot Be Said From This Result

What can be said:

  • In my environment, changing the model and resource settings appeared to break it out of Policy Artisan Mode.

What cannot be said:

  • Whether this was the sole cause
  • Whether it will definitely reproduce in other people’s environments

It is simply an observational fact that
“the behavior changed drastically before and after changing the settings."

Hints When Encountering the Same Situation

If you encounter a situation where:

  • Codex stops after just giving a strategy
  • Code is not updated at all
  • Permissions and settings appear to have no problems

Then trying to:

  • Bump the model up a tier
  • Increase the resource settings

is a countermeasure worth trying.

Especially when accompanied by large-scale refactoring or heavy testing,
settings aimed at saving tokens may end up working against you.

Conclusion: AI Also Has “Prerequisites for Working"

In this case, Codex entered the so-called “Policy Artisan Mode,"
where it would show a strategy but leave the code unupdated.

In my environment, reviewing the model and resource settings seemed to get it out of that state,
though I do not know if this is a universal solution.

However, if you encounter a similar situation,
reviewing your settings may provide a helpful clue.

AI Local LLMTerminal

Posted by 納戸工房