How To Code Almost Forever for $20/Month With Codex + GPT-6 Luna

Yesterday OpenAI released GPT-6 Luna.

And it might completely change the economics of AI coding.

Here is what most people are missing.

$20/month ChatGPT Plus plan with Codex now gives you access to GPT-6 Luna and Sol.

Most developers will do what they always do.

Throw the strongest model at every task.

Fix a typo → Sol High. Rename a variable → Sol High. Add a field → Sol High.

That is expensive and completely unnecessary.

Instead I am going to configure Codex like a real engineering organization.

Cheap workers for routine code. A specialist for decisions. Deterministic tools for verification. The senior engineer only for the genuinely hard stuff.

All for $20/month.

Here is the exact setup.

Why GPT-6 Luna changes this

Think about what an actual coding agent does during a normal day.

Fix a typo. Add a field. Update a test. Rename something. Implement a small endpoint. Debug a failing test. Add validation. Modify some SQL.

Most of this does not require the strongest reasoning model available.

GPT-6 Luna is designed specifically for focused, high-volume work.

It supports reasoning levels from none all the way to max. It has a 1.05M-token context window. API price: $0.10 per million input tokens (soooo cheap like you get more than 200 million token usage)

GPT-6 Sol costs $2.00 per million input tokens at standard rates.

20× more expensive.

So instead of:

EVERYTHING → Sol High

We build an escalation ladder:

Luna Low
   ↓
Luna Medium
   ↓
Luna High
   ↓
Sol High  ← only if we get here

Start cheap. Increase reasoning only when the evidence says it is necessary.

The expensive model becomes the exception. Not the default.

But something needs to make the decisions

Here is the problem.

Something needs to answer these questions after every coding pass:

→ Is this task small, medium, or difficult?

→ Did the implementation actually work?

→ Should we retry or escalate?

→ Are we actually finished?

You could use another LLM for this.

But then you are spending generative-model compute just to produce a decision.

That is wasteful for a yes/no question.

This is where Jev comes in.

━━━━━━━━━━━━━━━━━━

Meet Jev - a different kind of model

Jev is TypeSafe AI's first System One Model.

Traditional LLMs take context and generate text:

State → LLM → Tokens → Reasoning → More tokens → Parse → Decision

Jev is built differently:

State → Jev → Typed decision + probability + confidence

Instead of generating paragraphs about whether to retry, Jev returns:

RETRY confidence: 0.91

or:

ESCALATE confidence: 0.87

or:

COMPLETE confidence: 0.96

That is exactly what you want inside an agent loop.

Not another model writing prose about what it thinks you should do.

A fast, bounded, typed decision with a confidence score attached.

And Jev is almost free

Current published pricing:

Input: $0.042 per million tokens Output: $0.00

That is $42 per billion input tokens.

To put that in perspective: imagine making 10,000 Jev decisions, sending 2,000 tokens of context per decision.

20,000,000 input tokens × $0.042 per million = $0.84

84 cents for 10,000 decisions.

But cost is not actually the main reason to use it.

The interesting part is architectural.

You are separating the system into three distinct layers:

GENERATION  →  GPT-6 Luna / Sol
DECISIONS   →  Jev
TRUTH       →  compiler / tests / lint / build

Each component does only what it is good at.

Rule #1 : Don't use AI when software already knows the answer

This is the most important rule in the entire setup.

Imagine Luna just modified a Go service.

Do NOT ask Jev: "Does this code compile?"

That is ridiculous.

Run:

go build ./...

Do NOT ask: "Do the tests pass?"

Run:

go build ./...

Do NOT ask AI whether TypeScript compiles. Run the type checker. Do NOT ask AI whether formatting is correct. Run the formatter. Do NOT ask AI what changed. Run git diff.

The decision tree is simple:

Can software prove it?
        │
        ├── YES → run the deterministic tool
        │
        └── NO  → ask Jev

Jev handles uncertainty.

Software handles facts.

Every time you use Jev to answer something a compiler can answer, you are adding cost and latency for zero benefit.

The complete architecture

Here is the full system in one diagram:

          USER REQUEST
               │
               ▼
         ┌───────────┐
         │    JEV    │  ← classify: SMALL / MEDIUM / HIGH / ESCALATE
         │   ROUTER  │
         └─────┬─────┘
               │
    ┌──────────┼──────────┐
    ▼          ▼          ▼
  SMALL      MEDIUM      HIGH
    │          │          │
    ▼          ▼          ▼
Luna Low  Luna Medium  Luna High
    │          │          │
    └──────────┴──────────┘
               │
               ▼
          IMPLEMENTATION
               │
               ▼
         ┌───────────────┐
         │    VERIFY     │
         │  tests        │
         │  build        │
         │  lint         │
         │  typecheck    │
         └──────┬────────┘
                │
                ▼
               JEV
                │
      ┌─────────┼──────────┐
      ▼         ▼          ▼
  COMPLETE    RETRY    ESCALATE
                            │
                            ▼
                         Sol High

Luna writes the code. Jev makes the decisions. Tests and compilers establish facts. Sol only appears when evidence demands it.

Step 1 : Get Codex through ChatGPT Plus

The base cost of this entire setup:

$20/month.

Not $20 of API credits.

A ChatGPT Plus subscription.

GPT-6 Sol and Luna rolled into Codex for Plus users on September 22.

That means you already have access to both models inside Codex if you have Plus.

Jev is the only external service you are adding and it is priced at $0.042 per million input tokens.

At realistic usage volumes, your Jev spend will be measured in cents per month.

The base cost stays at $20.

Step 2 : Get access to Jev

Go to typesafe.ai.

Jev is currently in early access. TypeSafe is bringing developers off its waitlist as capacity opens.

Once you have access, create an API key.

Add it to your environment:

export TYPESAFE_API_KEY="your_key_here"

Do not put the actual key inside your Codex personalization. Do not put it in AGENTS.md. Do not commit it to GitHub.

Your Codex instructions should reference TYPESAFE_API_KEY - not contain the value itself.

Step 3 : What Jev actually decides

In this setup, Jev has a very specific job.

It handles bounded decisions around the coding loop:

→ classify task complexity (SMALL / MEDIUM / HIGH / ESCALATE)
→ select reasoning lane for Luna
→ decide whether another iteration is justified
→ decide whether a failed attempt warrants retrying
→ detect when the task's blast radius has grown
→ determine whether to escalate
→ assess whether evidence supports completion

What Jev does NOT do:

→ write code
→ design architecture
→ replace Luna's reasoning
→ replace tests
→ answer questions that compilers can answer

Think of it as the tiny control model sitting around the expensive work.

Here is what a typical Jev state looks like:

Task:
Add validation to POST /users.

Files changed:
handlers/users.go
services/users.go
services/users_test.go

Verification:
go test ./... → PASS
go vet ./...  → PASS

Diff:
+ email validation
+ duplicate handling
+ 4 new tests

Question:
Does the evidence support completion?

Options:
COMPLETE / VERIFY_MORE / RETRY / ESCALATE

Jev returns:

COMPLETE confidence: 0.97

Done. No Sol. No review loop. No unnecessary escalation.

Step 4 : Configure Codex

Open: Codex → Settings → Personalization

Paste this into the Codex instructions box:

## Default multi-model coding orchestration

For every software-engineering request, automatically operate
as an architect and orchestrator.

Goal: complete work reliably using the minimum necessary
model and reasoning level.

## Jev decision model

Jev is available as a decision/control model.

Authentication: read TYPESAFE_API_KEY from the environment.
Never print, expose, log, or commit this key.

Use Jev ONLY for bounded decisions:
- task complexity classification
- reasoning-level routing
- continue vs stop
- retry decisions
- escalation decisions
- completion assessment

Do NOT use Jev for:
- writing code
- generating patches
- architecture design
- anything deterministic tooling can answer

## Initial routing

Before implementation, classify the task:

SMALL  → Luna, low reasoning
MEDIUM → Luna, medium reasoning
HIGH   → Luna, high reasoning
ESCALATE → Sol, high reasoning

Always use the lowest sufficient lane.

## Deterministic verification (critical rule)

Prefer deterministic evidence over AI judgment whenever possible.

Tests         → run the test runner
Compilation   → run the compiler
Types         → run the type checker
Lint          → run the linter
Changed code  → run git diff

Never ask Jev to determine something software can determine.

## Agent loop

After each implementation cycle:

1. Inspect the actual diff
2. Run relevant deterministic checks
3. Gather concise evidence
4. Use Jev for any remaining judgment
5. Choose: CONTINUE / RETRY / VERIFY / ESCALATE / COMPLETE

## Escalation path

Luna Low → Luna Medium → Luna High → Sol High

Escalate only when evidence warrants it:
- repeated attempts fail
- tests keep failing
- security-sensitive code changed
- architectural uncertainty remains
- Jev confidence is below threshold

Do not escalate because a stronger model is available.

## Completion

Only report completion when:
- requested behavior is implemented
- deterministic checks pass
- diff matches requested scope
- no unresolved failures exist

Never hide failed verification.

Save it. That is the entire setup.

What happens when you code now

Let's walk through a real example.

You type: "Add validation so users can't register with disposable email domains."

Step 1: Jev classifies the task.

MEDIUM confidence: 0.92

Step 2: Codex routes to Luna Medium.

Luna inspects the relevant code and implements the change.

Step 3: Codex runs deterministic verification.

go test ./... → PASS go vet ./... → PASS go build ./... → PASS

Step 4: Codex sends evidence to Jev.

Tests: PASS Build: PASS Lint: PASS Unexpected files changed: NO Relevant tests added: YES

Step 5: Jev responds.

COMPLETE confidence: 0.97

Done.

No Sol. No Max reasoning. No extra reviewer loop.

Luna Medium handled it.

What happens when something goes wrong

Same task.

But now the test suite is failing in authentication code.

Jev sees one failed attempt and returns:

CONTINUE

Luna Medium investigates. Second attempt fails.

Now Jev sees:

Attempt 1: failed Attempt 2: failed

Failure affects:

• authentication
• session creation
• user registration

Jev returns:

ESCALATE confidence: 0.89

Only now does Sol High enter the picture.

Expensive reasoning becomes the exception. Not the default.

That is the entire point.

Where NOT to use Jev

Do not call Jev after every tiny action.

This is an easy mistake.

You do not want:

read file → Jev search repo → Jev open file → Jev edit line → Jev run command → Jev

Now you have created orchestration overhead with zero benefit.

Use Jev at decision boundaries only:

TASK ARRIVES         → Jev: classify and route
IMPLEMENTATION PASS  → deterministic tools verify
AMBIGUOUS RESULT     → Jev: continue or retry?
AFTER SECOND PASS    → deterministic tools again
ESCALATION QUESTION  → Jev: escalate or keep going?
FINAL EVIDENCE       → Jev: completion gate

Four to six Jev calls per task.

Not forty.

Confidence scores are where this gets powerful

Jev does not just return a decision string.

It returns a probability.

That means you can build actual policies:

Jev says COMPLETE confidence > 0.95

• all tests pass
• build passes
• diff is within scope → finish automatically

But:

Jev says COMPLETE confidence = 0.61 → do not trust autonomous completion → force a review pass

Or:

ESCALATE probability > 0.85 → immediately go to Sol High

You are not just prompting models anymore.

You are building a control system around uncertainty.

That is genuinely new.

━━━━━━━━━━━━━━━━━━

My hypothesis on what the task distribution looks like

Over a large enough set of normal development work, I expect:

55% → Luna Low      ← typos, small edits, renames
26% → Luna Medium   ← new endpoints, small features
13% → Luna High     ← debugging, complex logic
 6% → Sol High      ← architecture, security, migrations

That means 81% of tasks never need anything above Luna Medium.

These are not results. They are the hypothesis I am going to test.

I will track every task across a real month of development:

Tasks completed Tasks per model lane Jev decisions made Failed verification passes Jev confidence accuracy Total Jev cost Times Codex subscription limits the work

The metric that actually matters:

Cost per successfully completed coding task.

Not token counts.

Not benchmark scores.

Real software. Real cost. Real measurement.

Can you really code "almost forever" for $20?

No subscription is literally unlimited.

That is why I said almost forever, not forever.

Codex on Plus has usage limits, and heavy workloads will hit them.

A giant repository with max-reasoning workflows will consume more than renaming a function.

The interesting question is not whether $20 is infinite compute.

It is how far you can stretch the subscription when:

→ Luna is the default workhorse instead of Sol

→ Jev handles decisions instead of a generative model

→ Tests and compilers handle verification instead of AI

→ Sol only appears when evidence demands it

Luna was specifically designed for focused, high-volume work.

It just rolled into Codex for Plus users.

That is why now is the time to test this.

One $20 subscription. One month. Real software.

That is the experiment.

No toy benchmarks. No token math pretending it equals useful engineering.

Real coding tasks. Tracked properly.

The metric that matters: how much real software does $20 build?

My bet is that the vast majority of everyday development work does not need the smartest model on every step.

If that is true, the future of AI coding is not one giant model that does everything.

It looks like an engineering organization.

And it runs for $20/month.

If this was useful:

→ Repost to share it with every developer paying too much for AI coding

→ Follow @sairahul1 for more setups like this

→ Bookmark this, the Codex config at the end is copy-paste ready

I write about AI, building products, and systems that work while you sleep.