# The Surface Writes the Prompt: Codex vs Claude Code vs Claude.ai, Side by Side

Author: Maksym Tytarenko | Date: 2026-07-16 | Category: AI & ML | Tags: codex, claude, ai prompts, agent design, terminal, web chat, automation, efficiency
Canonical: https://www.tytarenkoagency.com/blog/surface-dictates-prompt-codex-claude

> A side-by-side read of the Codex Desktop, Claude Code, and claude.ai system prompts: the coding-agent prompts resemble each other more than either resembles the consumer chat — evidence that the product surface, not the vendor, shapes prompt architecture.

I read the system prompts of three shipping AI products side by side: OpenAI Codex Desktop, Claude Code (the CLI), and claude.ai web chat. Two of the three come from the same vendor and are powered by the same family of Claude models — so you would expect the two Anthropic prompts to read like siblings, with OpenAI's as the outlier. In the prompts I sampled, the opposite holds. **The coding-agent prompts resemble each other more than either resembles the consumer-chat prompt.** That supports a hypothesis worth taking seriously: the surface shapes the prompt more than the vendor does.

My sources are the publicly archived prompt extractions in the CL4R1T4S repository plus the claude.ai system prompts that Anthropic itself publishes in its release notes. These are not equally reliable, and the samples are not from the same moment in each product's life — I'll flag both limitations as they come up, and there is a provenance table at the end.

![An infographic depicting the comparison of system prompts between the three AI products.](https://adltqzpaelnsrebtkzfj.supabase.co/storage/v1/object/public/blog-images/ai-generated/uploads/20260716_194827_56b74e89.png)

## Same vendor, different species

Both terminal products prompt for the same job: an agent that works in your repo while you watch. Their prompts converge on outcome-first reporting, token economy, file-based memory, and sandboxing with explicit permission escalation. The web chat prompt is a different genre altogether — a values-and-governance document. Anthropic's published claude.ai prompt spends its length on refusal handling, child safety, legal and financial caution, user wellbeing, evenhandedness, and anti-sycophancy rules, with barely a word about tools or files.

If you know the surface — terminal agent vs. web chat — you can predict the shape of the prompt better than if you know the vendor. At least across this sample; a rigorous test would need same-date snapshots of all three, which extraction archives don't give you.

## Policy moved into prose

The size gap between generations of these prompts is the most concrete evidence of where the engineering went.

The earliest Claude Code prompt archived in CL4R1T4S is roughly **264 words**. (The archive labels the file `Claude_Code_03-04-24.md`, but the date encoding is ambiguous and Claude Code only launched publicly in February 2025 — so I treat it simply as an early extracted snapshot of unknown exact date.) It fits on one screen: "Answer concisely with fewer than 4 lines when possible," "Minimize output tokens while maintaining helpfulness," "Never commit changes unless explicitly asked," "Use Agent tool for file search to reduce context usage," and an auto-loaded `CLAUDE.md` file as memory. That is nearly the entire product.

The current Codex Desktop extraction (the archive's `5.6-Sol` file, whose text identifies the agent as GPT-5-based) is roughly **42,000 words** — two orders of magnitude more. It covers skills and how to use them, escalation requests with approved command prefixes, memory, plugins, connectors, automations, and thread coordination. Anthropic's published claude.ai prompt sits in between at roughly **8,000–9,000 words**, and almost none of it is about tools — it is conduct policy. (Word counts are plain word counts of the source files.)

To be precise about what this shows: a huge extracted prompt does not mean the whole harness literally lives in one system message — Codex still depends on runtime code, tools, and sandbox enforcement, and an extraction may be a bundle of dynamically assembled blocks. What the growth does show is that **much more of the product's policy became explicit prose**: the prompt bundle now reads as a control plane for a harness whose enforcement stays in code.

## The convergent skeleton of the coding agents

Strip the branding and the two coding-agent surfaces share one operational skeleton:

- **Skills** — packaged instructions the agent loads for specific kinds of tasks.
- **File-based memory** — `AGENTS.md` for Codex, `CLAUDE.md` for Claude Code: a file in the repo that tells the agent how the project works, loaded automatically.
- **Sub-agents / thread coordination** — spawning parallel workers and coordinating across threads.
- **Sandboxing with permission escalation** — a restricted default plus an explicit protocol for requesting more access, down to approved command prefixes in Codex's case.

claude.ai shares some response-style principles with them (see the formatting rule below), but its published prompt is primarily a consumer-governance document — the repo-agent skeleton simply isn't its job.

## The anti-over-formatting rule, almost word for word

The clearest single fingerprint of convergence is the formatting rule. Codex says:

> "Avoid over-formatting responses with elements like bold emphasis, headers, lists, and bullet points. Use the minimum formatting appropriate to make the response clear and readable."

Anthropic's published claude.ai prompt says:

> "Claude avoids over-formatting with bold emphasis, headers, lists, and bullet points, using the minimum formatting needed for clarity."

![A visual guide illustrating the anti-over-formatting rule with examples.](https://adltqzpaelnsrebtkzfj.supabase.co/storage/v1/object/public/blog-images/ai-generated/uploads/20260716_194725_5fa0d1d7.png)

Two competitors, near-identical sentences. The similarity is consistent with convergent product learning — both teams appear to be treating the same failure mode of models drowning answers in bullets and bold. The prompts alone can't show whether the wording emerged independently or through mutual visibility; what they do show is that both vendors now consider over-formatting a failure worth legislating against.

## Character contrast: where the personalities differ

A shared skeleton does not mean identical character. The prompts encode noticeably different philosophies about the user's attention:

![A comparative chart of token philosophies and governance focuses of the three AI products.](https://adltqzpaelnsrebtkzfj.supabase.co/storage/v1/object/public/blog-images/ai-generated/uploads/20260716_194618_0382bbf3.png)

| Surface | Attention philosophy | Signature rules |
|---|---|---|
| **Codex Desktop** (current extraction) | Tokens as a public good: hard minimalism plus a live "heartbeat" | The user "should not be left without a commentary update for more than 60 seconds"; "Lead with the outcome rather than the steps you took to get there"; "the user should never have to read your message twice" |
| **Claude Code CLI** (current product, as observed in daily use) | Readable over concise | The final message is fully self-contained — everything the user needs, no digging through interim updates |
| **claude.ai Web** (vendor-published prompt) | Conduct over mechanics | "Claude does not want to foster over-reliance on Claude or encourage continued engagement with Claude" |

Note the provenance split: the early 264-word snapshot quoted above is pure token-minimalism ("fewer than 4 lines"), while the readable-over-concise, self-contained-final-message character describes the current-generation product — Claude Code's style evolved between those two points.

Codex treats every token as spent from a shared budget and compensates with frequent, tiny status updates. Claude Code optimizes for a single complete answer you can read once. claude.ai spends its words on how to behave — including, remarkably, a rule against maximizing engagement.

## Two anecdotes (stories, not evidence)

While researching this piece I collected two amusing qualitative anecdotes — they illustrate the vibe, but prove nothing on their own.

First, a small model I used for fetching once mislabeled the Codex system prompt as "Claude Code" — it read a 42,000-word OpenAI document and classified it as the competitor's product.

Second, during fact-checking, a fetch model refused to analyze the Codex prompt file at all — it decided it was being asked to *become* Codex and declined. The document reads so much like live agent instructions that a model couldn't tell analysis from installation. Either outcome could be an artifact of the specific model or retrieval wrapper, so take both as color, not data.

## Method and limitations

What was actually compared:

| Sample | Date | Source type |
|---|---|---|
| Early Claude Code prompt (~264 words) | unknown early snapshot (product launched Feb 2025) | extracted (CL4R1T4S) |
| Codex Desktop `5.6-Sol` (~42,000 words) | mid-2026 archive state | extracted (CL4R1T4S) |
| claude.ai prompt (~8,000–9,000 words) | June 2026 (Claude Fable 5) | vendor-published (Anthropic release notes) |
| Claude Code current character | July 2026 | author's daily-use observation |

The honest caveats: extracted prompts are model-reported, not vendor-verified — they drift, and some hallucination is baked into the extraction method. The snapshots span different product ages, so product maturity is a confound I can't fully separate from the surface effect. And no formal similarity metric was used — this is a close reading. Anthropic is the notable exception on sourcing: it publishes the claude.ai prompts officially, which makes that the only sample here citable with full confidence. Treat the headline claim as a hypothesis this sample supports, not a proven law.

## The takeaway for builders

If you are designing an agent harness, the sampled prompts point at one skeleton worth copying: skills, file-based memory, sub-agents, permission tiers, and an anti-over-formatting rule. Teams with different models, different businesses, and different users ended up shipping exactly this shape for the coding-agent surface. The prompt is no longer a personality blurb — it increasingly reads as the architecture document of the product, and the surface it runs on writes most of it for you.

## FAQ

### Why would the surface shape the prompt more than the vendor?
Because the surface sets the constraints the prompt must solve: a terminal agent needs token economy, file memory, and permission escalation; a web chat needs conduct policy at consumer scale. Vendors solving the same constraints write the same kinds of rules. In this sample the coding-agent prompts resemble each other more than either resembles the consumer-chat prompt.

### What is the agent skeleton I should copy?
Skills, file-based memory (`AGENTS.md` / `CLAUDE.md`), sub-agents or thread coordination, and sandboxing with an explicit permission-escalation protocol. Both coding-agent products in this comparison converged on it.

### How big are these system prompts?
The archived early Claude Code prompt is ~264 words; Anthropic's published claude.ai prompt is roughly 8,000–9,000 words; the current Codex Desktop extraction is roughly 42,000 words. The growth tracks how much of the product's policy moved into explicit prose.

### Are extracted system prompts reliable for building my own agent?
They are model-reported, not vendor-verified, and they drift as vendors ship updates. Use them as evidence of design patterns, not as exact specifications — and prefer officially published prompts (like Anthropic's release notes) where they exist.

## Related reading

- [Don't Install GitHub Spec Kit — Steal These Three Ideas Instead](https://www.tytarenkoagency.com/blog/dont-install-spec-kit-steal-ideas)
- [Enhancing Code Review Reliability with a Multi-Pass Fan-Out Reviewer Strategy](https://www.tytarenkoagency.com/blog/enhancing-code-review-reliability-with-a-multi-pass-fan-out-reviewer-strategy-b08539)
- [AI Automation Architectures for Bootstrapped SaaS: Open-Source Patterns to Match Enterprise Scale](https://www.tytarenkoagency.com/blog/ai-automation-architectures-for-bootstrapped-saas-open-source-patterns-to-match-enterprise-scale)

## Sources

- [CL4R1T4S — public archive of extracted system prompts (GitHub)](https://github.com/elder-plinius/CL4R1T4S)
- [The early Claude Code extraction used for the word count (CL4R1T4S)](https://github.com/elder-plinius/CL4R1T4S/blob/main/ANTHROPIC/Claude_Code_03-04-24.md)
- [The Codex Desktop `5.6-Sol` extraction (CL4R1T4S)](https://github.com/elder-plinius/CL4R1T4S/blob/main/OPENAI/Codex_Desktop/5.6-Sol_SystemPrompt.md)
- [Anthropic release notes — officially published claude.ai system prompts](https://platform.claude.com/docs/en/release-notes/system-prompts)
- [Anthropic — Claude 3.7 Sonnet and Claude Code (February 2025 launch)](https://www.anthropic.com/news/claude-3-7-sonnet)
- [OpenAI — Introducing the Codex app](https://openai.com/index/introducing-the-codex-app/)
- [OpenAI — Unrolling the Codex agent loop](https://openai.com/index/unrolling-the-codex-agent-loop/)