Codex First logo

Codex First

Community
boringmarketer
codex-first

Route implementation work-orders to GPT-5.6 lanes via Codex; Claude specs, orchestrates, reviews, verifies. Use when a task is a frozen-spec build, mechanical migration, test fill, bulk sweep, or CI fix — anything that reads as a work order rather than a design problem.

Overview

Publisherboringmarketer
Repositorykimi-first
Skill namecodex-first
Stars
51
Forks
2
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by boringmarketer on GitHub. Read the source before you install it.

Installation

Install the Codex First AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/boringmarketer/kimi-first/tree/main/skills/codex-first
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/boringmarketer/kimi-first.git /tmp/kimi-first
mkdir -p .claude/skills
cp -r /tmp/kimi-first/skills/codex-first .claude/skills/codex-first
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Codex First in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Codex First on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Codex First is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Codex First

Claude Code sessions only. Rationale: GPT-5.6 lanes run flat-rate on the ChatGPT plan and top the coding index; Fable's edge is judgment, specs, orchestration, review. Codex types, Claude thinks and verifies. (Adapted from steipete/agent-scripts for James's rig.)

Route

Delegate to Codex (default for hands-on volume):

  • implementation from a frozen spec; refactors; mechanical migrations/sweeps
  • bug fixes with a known repro; test writing; coverage fills
  • CI fixes, dependency bumps, scripts/tooling
  • bulk exploration where raw reading ≫ the answer

Keep in Claude (never delegate):

  • design, architecture, naming, product judgment — tasks where writing the spec IS the work
  • tiny edits (<~20 lines, single obvious change) — delegation overhead loses
  • anything needing session tools: MCP, browser, PostHog, memory
  • prod operations, always: prod DB (psql), Railway env/deploys, Stripe, DNS, customer emails, anything reading .env/secrets. Codex never touches prod credentials or runs with them in reach.
  • destructive/irreversible ops, releases, pushes, merges — Claude-side per repo protocol
  • review of Codex output — never delegated, never skipped

Heuristic: prompt reads as a work order → delegate; writing it forces decisions → design, keep it. Mixed task: Claude designs, freezes spec, delegates build-out.

Model/effort routing (updated Aug 26 — James's strategic-loop topology)

  • IMPLEMENTATION lanes: gpt-5.6-terra, effort ultra — big, BOLD, atomic work orders (whole migrations, whole screens, whole adapters). Clear frozen spec in, commits out. Claude reviews at the seams, not over the shoulder.
  • REVIEWER / THINKING PARTNER: gpt-5.6-sol, effort high→max→ultra — adversarial passes, certification reads, design attacks, strategy pressure-tests. Sol is no longer escalation-only; it is the standing second brain in loops (build: terra → attack: sol → synthesize: Claude).
  • Routine/cheap orders: gpt-5.6-luna, effort high. When the 5.6 weekly limit is out, gpt-5.3-codex-spark runs on a SEPARATE quota — use it for routine/mechanical lanes only; judgment and class-1 review stay on Claude seats.
  • Opus 5 subagents (via Claude's Agent tool): completeness reads, design rulings, funnel/product craft — the divergent-thinking seat in loops.
  • NAMED SEATS (Sep 1, ~/.claude/agents/, load at session start): designer (Opus xhigh, gating design verdict), completeness-reader (Opus xhigh, scope/journey/doc-truth + overengineering strip list, before any merge or "live" claim), explorer (Sonnet low, read-only sweeps — file dumps never enter Fable's context), verifier (Sonnet xhigh, browser/MCP/walkthrough films with evidence, never verdicts). Fable keeps: WO authoring, prod ops, merges, final gate. Hands-on reading in the Fable seat is the priciest seat doing the cheapest work — delegate it. Skip Haiku (200K, a generation back).
  • Escalate effort on failure; choose SEAT by role (terra builds, sol attacks, opus designs, Claude gates + synthesizes + ships).
  • Every lane must COMMIT its work (atomic commits per tripwire/feature); Claude verifies commits exist + runs the repo's own proof set before any merge (for TS repos typically: lint, typecheck, unit tests, build, plus any disposable-infra verifier the repo carries).

Invoke

Prompt via temp file in the scratchpad, never inline quoting:

bash
P=$(mktemp "$SCRATCHPAD/codex-XXXXXX"); cat >"$P" <<'EOF'
<goal · repo + key paths · constraints ("don't touch X") · non-goals ·
 proof expected (exact test command) · output shape ("report files changed + test output")>
EOF
codex exec --yolo -C <repo> \
  -c model="gpt-5.6-terra" -c model_reasoning_effort="ultra" \
  -o "$SCRATCHPAD/codex-last.md" - <"$P" 2>/dev/null
  • run long jobs with Bash run_in_background; read the -o file on completion
  • --yolo only when the working dir is a repo without prod secrets in reach; otherwise default sandbox and review the command requests
  • follow-ups: codex exec resume --last from the repo dir (cheaper, keeps context)
  • parallel independent orders OK: separate worktrees/dirs, separate -o files
  • PRUNE worktrees after each lane lands: rm -rf /private/tmp/<repo>-* + git worktree prune (Jul 30 incident: 219 accumulated worktrees filled the disk to 0 bytes mid-review)
  • alternatively spawn the codex:codex-rescue subagent (plugin) for shared-runtime jobs

Prompt contract

Codex starts with ZERO session context. Every prompt: goal, exact repo/paths, constraints, non-goals, proof expected, output shape. Spec quality decides success.

Verify (Claude, always)

  • git status -sb + read the FULL diff; judge like a hostile contributor-PR review
  • run the focused tests yourself or demand proof output; Codex claims are advisory
  • iterate via resume; after 2 failed rounds, take over and do it directly
  • ship through normal repo protocol (commit/create-pr skills, CI watch) — Claude's hands on the merge button, never Codex's
  • substantive results feed [[adversarial-review]] before merge

Frequently asked questions

What does the Codex First AI skill do?

Route implementation work-orders to GPT-5.6 lanes via Codex; Claude specs, orchestrates, reviews, verifies. Use when a task is a frozen-spec build, mechanical migration, test fill, bulk sweep, or CI fix — anything that reads as a work order rather than a design problem.

Why use Codex First on TypingMind?

Because you install it once and use it with any model. Codex First is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Codex First in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/boringmarketer/kimi-first/tree/main/skills/codex-first. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Codex First?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Codex First?

As many as you like. As long as a model supports skills, you can use Codex First with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Codex First AI skill free?

Yes. It is published on GitHub by boringmarketer under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇