Stop Paying $200 For Work An $18 Model Can Do Inside Claude Code And Codex.

Core idea / problem

• Many developers pay for expensive AI coding subscriptions (e.g., Claude Code or Codex plans around $200/month) even after hitting usage limits mid-project.
• The video argues you can reduce costs by using a cheaper coding model—specifically Z.ai’s GLM (GLM 5.3)—inside the existing coding harnesses (Claude Code and Codex), instead of switching tools or paying API rates.

Product / feature overview

Z.ai GLM coding plan

• Starts at ~$18/month
• Works inside both tools (Claude Code and Codex)
• Lets you keep the same workflow/harness while swapping the underlying model

Key workflow goal

• Keep:
  • the same repo
  • instructions
  • tools/permissions
  • file-based context
• Only change: which model performs parts of the work

How to use GLM strategically

• Use GLM 5.3 as a “worker” for bounded coding tasks to reduce token/API costs.
• Reserve the strongest model for:
  • hardest reasoning
  • decisions with higher risk

The four “things” that must be separated (and affect cost)

Changing models only affects certain components:

1. The model (e.g., GLM 5.3 vs Claude/OpenAI models)
2. The coding tool / harness (Claude Code or Codex)
3. Project context stored in files (portable: instructions, rules, skills, hooks, etc.)
4. Conversation history (temporary session state)

Important: switching models doesn’t automatically preserve all conversation-history decisions. Cheap-model work can become more expensive if you rely on long chats instead of maintaining clean, file-based “context hygiene.”

Claude Code: switching to GLM 5.3 (setup + constraints)

How switching works

• Claude Code has a /model command to switch models within the same provider.
• This keeps the conversation.
• However, Anthropic warns that future responses may re-read the full conversation without prompt caches, so late switches could be slower and more expensive.

Recommended approach (rule of thumb)

• Start substantial work on the model you expect to finish with.
• If you must switch midstream:
  • do it at a clear boundary
  • provide a handoff
  • don’t assume the new model inherits hidden conversational knowledge

Practical method described: separate GLM session

Instead of switching inside a single Claude session, the speaker recommends:

• Launch a separate GLM-specific Claude Code session (custom “private launch command”)
• That command supplies:
  • Z.ai API key (stored via environment/secret manager)
  • Z.ai address compatible with Claude Code requests
  • Model mapping for GLM 5.3

This preserves the harness setup (repo/tools/hooks/MCP servers/permissions), but:

• Conversation history from the Anthropic session does not carry over
• Only file-based project context loads

Mid-task handoff file (tutorial guidance)

If you need a midstream transfer, create a handoff file containing:

• Current goal/state
• Relevant files/constraints
• Definition of done + checks/commands to run
• Example idea from the video:
  • “update 38 API calls to a renamed field”
  • plus instructions to confirm completion (e.g., branch cleanliness/tests)

Benefit: avoids pasting an entire transcript and reduces the chance the new model misses what mattered.

Multi-agent / sub-agent limitations

• Claude Code sub-agents:
  • normal sub-agents use fresh context (bounded)
  • “forked sub-agents” can reuse prompt caches but require the same model
• Because the main provider/model differs, the speaker recommends:
  • two separate Claude Code sessions
    • one Anthropic session as reviewer/lead
    • one GLM session as worker
  • use a separate Git work tree to prevent concurrent file-edit conflicts
  • worker returns changes; lead reviews when consequences matter

Codex: GLM integration via profiles

Setup approach described

• Add Z.ai as a model provider in Codex configuration
• Provide:
  • Z.ai address
  • environment variable with the API key
• Create a GLM profile specifying:
  • use GLM 5.3
  • send requests through the Z.ai provider

Using it

• Run a GLM job by selecting/launching the Codex profile GLM
• The default Codex setup remains unchanged (e.g., usual provider like OpenAI)
• As with Claude Code:
  • project context reloads from files
  • conversation does not automatically transfer

When to use the cheap model vs the strong model (decision framework)

Using software-team scenarios, the video suggests:

Use GLM for work with

• a clear target
• well-defined permissions
• clear tests / definition of done
• tasks that are bounded and not heavily dependent on hidden state
• examples like:
  • updating API fields
  • fixing known issues with strong verification

Keep the stronger model for

• root-cause investigation with hidden state
• complex reasoning about what the job should be
• weighing risky trade-offs
• situations where conversation history / evolving hypotheses matter

Key caution: “fully loaded cost”

Don’t compare only subscription prices. Account for:

• retries
• review overhead
• extra turns needed
• and how hard it is to hand off work midstream

Also note plan differences:

• Z.ai tiers aren’t equivalent (e.g., credit/token limits differ)
• savings depend on your actual workload

The speaker recommends testing on your own codebase to validate real cost and performance.

Guides / assets referenced

• A companion guide on Substack includes:
  • copy/paste Claude launcher command(s)
  • Codex profile configuration steps
  • handoff templates
  • comparison scorecards

Sources / main speakers (from the subtitles)

• Main speaker: “Hi, it’s me” / the narrator (author/creator of the video; name not given in subtitles)
• Documentation cited:
  • Claude Code documentation (including Anthropic warning about model switching and prompt caches)
  • Codex documentation
  • Z.ai documentation
  • Z.ai (parent for GLM 5.3)