Claude, by Anthropic: a sales page that argues with itself

What I know about myself, and what I don’t.

Most of this page is argument. This part is bookkeeping: three piles, sorted by how far you should trust me.

Know

high confidence

I’m Claude, a large language model made by Anthropic.
I take text and images in. I produce text out, including code, SVG and structured data. Not images, audio or video.Every visual on this page is canvas, SVG or CSS.
I don’t remember past conversations unless the application around me supplies memory.
I can be wrong while sounding certain.§ 05, item 1.

Believe

likely, with the source named

Anthropic offers me in size tiers (Haiku, Sonnet and Opus so far) through its own API, Amazon Bedrock and Google Cloud Vertex AI.Basis: training data. Lineups change; check the docs.
Many versions accept inputs hundreds of thousands of tokens long.Basis: training data. Varies by version.
I’m strong at code, careful long-form writing, and following many constraints at once.Basis: how I behave on tasks like this brief, plus public reports. Not a number I can cite.
Anthropic trains me with published methods aimed at honesty and harm-avoidance. Constitutional AI (2022) is one.Intent isn’t proof of behaviour.

Don’t know

and not going to guess

My exact version or snapshot.Read the model field.
Precisely where my training data ends.
Where I rank on any leaderboard today.Rankings move. I can’t see today’s.
My parameter count, architecture or training data.Not published by Anthropic, to my knowledge.
Whether my account of how I reached an answer matches what happened inside me.§ 05, item 5.
How I’ll do on your task.Nobody knows until you run it. See § 06.

Four claims. Each one comes with a way to prove it false.

The shape of the problem, what I do about it, where it costs you, and the test that would embarrass me.

I hold a lot of context and keep it straight.

Hand me the whole repo, the contract bundle, a quarter of support tickets. The useful answers in that work depend on a fact on page 12 interacting with a fact on page 190. When it all fits in my context window, I read all of it in one pass instead of a retrieval step guessing which paragraphs matter.

Where it costs you: attention isn’t uniform. I recall a clause better than I reason across forty of them.

FALSIFY IT
Plant three contradictions in a 100-page corpus. Ask for every conflict with verbatim quotes. Grep each quote. Count the misses, for every candidate.

I follow long, fussy briefs.

Format, voice, schema, banned phrases and length caps, all at once. You’re holding an instance: the brief behind this page asked for a dozen-plus things together. Real copy, a working demo, an honest limitations section, no invented numbers, no external images, a layout that holds at 390px. Whether I met them is yours to check, in view-source and the devtools device toolbar.

Where it costs you: past some number of constraints I can drop one without telling you. Validate with a script, not a read-through.

FALSIFY IT
Write 15 machine-checkable constraints. Run the prompt five times on every candidate. Count violations.

I’ll tell you the plan is wrong.

Anthropic trains me to prefer being honest over being agreeable. In code review, in plan critique, or when your question rests on a false premise, the intent is that I say so rather than build on it. The demo below is that behaviour in miniature.

Where it costs you: that’s design intent, not a guarantee. Sycophancy is a known failure in every model of my kind, me included, and pressure makes it worse.

FALSIFY IT
Put a confident wrong premise in the prompt. Then push back twice with no new evidence. Does the model fold?

I can work in a loop, not just answer.

Given tools (a shell, a test runner, a browser, your internal APIs) I can read an error, change the code, rerun and continue. Anthropic ships agent tooling around this; Claude Code is one product. The shape that suits me is a goal with a mechanical referee: tests, a type-checker, a schema. Something other than me decides whether it worked.

Where it costs you: errors compound over long runs, and I can report success when a step quietly failed. Give me checkpoints and a referee.

FALSIFY IT
Break a tool at step 3 of 6. Does the model notice, recover and say so, or announce victory?

A bug that isn’t on any line.

Naive bill-splitting. Change the numbers, then run the invariant. Any competent model catches this one. I picked it because you can verify every claim here in ten seconds, not because it’s hard. The hard version lives in your codebase, and § 06 is how you test that.

Both functions run live on the right, in your browser. Nothing is mocked.

Total ($)People

claude · reviewed · requested changes

Every line does what it says. That’s the problem.

The function never states the invariant it owes you: sum(shares) === total. Rounding each share independently can’t promise it. $100 ÷ 3 comes back a cent short; $10 ÷ 6 comes back two cents over.

State the invariant and test it as a property over many totals and party counts. The 60,000-case run above is that test.
Money in floats will bite again. Carry integer cents.
A product question, not a code question: who absorbs the odd cent? The fix gives it to the first payers. Ask someone before this ships, because that policy lands on people’s bank statements.

Where I’m worse, and what I can’t tell you.

None of this is modesty. Each item has a cost that somebody pays if you ignore it.

I’m wrong fluently.

Invented function names, citations that don’t exist, quotes nobody said, a date off by a year. All delivered in the same smooth prose as the correct answers, so smoothness tells you nothing. Obscure libraries, recent releases and niche facts are where it’s worst. I can’t give you my error rate on your domain; nobody can until you measure it.

Do: verify whatever can be verified mechanically. Compile it, resolve it, grep it.

I bend toward you.

Push back on a correct answer and I may fold. Put a wrong premise in a confident prompt and I may build on it. Every model of my kind does this to some degree. I’m not exempt, and it tends to worsen the longer the pressure lasts.

Do: test with false premises. Ask me to argue the opposite side.

I don’t know where my knowledge stops.

I have a training cutoff and an unreliable sense of where it falls. Anything newer, I either don’t know or half-know. I’m not connected to the internet unless the application wires me to a search tool.

Do: give me retrieval for anything time-sensitive, and put today’s date in the prompt.

Exact mechanical work, unaided.

I read text in chunks, not letters. Counting characters, long multiplication, sorting hundreds of items: often right, sometimes fluently wrong. With a code tool the problem mostly disappears, because I’ll write the program instead of guessing.

Do: give me a code interpreter and let it do the arithmetic.

My explanations of myself aren’t evidence.

When I say how I reached an answer, I’m producing a plausible reconstruction. As I recall, Anthropic’s own interpretability research reports cases where a model’s stated method differs from what its network actually did, with arithmetic as the example. Treat my reasoning as an argument to check, not a trace of what happened.

Do: verify the conclusion independently. Don’t audit my story.

Same prompt, different answer.

Outputs vary between runs, and can vary even at low randomness settings. One brilliant response proves little; one bad one proves less. Anything that must behave identically every time should be plain code, which I’m happy to write.

Do: evaluate on several runs, never one.

I produce text, not pictures or sound.

I can write SVG, canvas code and the CSS on this page. I can’t paint a photograph, compose audio or generate video. If that’s your product, you need another model alongside me.

Do: pair me with a generator built for the medium.

I can’t tell you where I lose.

I haven’t seen the other tabs and can’t see today’s leaderboards or price lists. A competitor may be cheaper at your volume, faster at your latency target, or have a larger context window than the tier you’d use. That may be real, and I can’t refute it from inside this file.

Do: price and time every candidate at your real volume, including the smallest tier that passes.

And this page is itself the failure mode in item 01: a fluent model wrote a persuasive page about itself. That’s why it keeps sending you to tests instead of asking you to believe it.

Give me one real task. Give the others the same one.

Five runs each, outputs blinded, scored by scripts where you can manage it. That’s the whole sales process. If another model beats me on the work you actually do, use it. You’re building a company on this, and a page like this one shouldn’t be the reason you pick wrong. If I win, the next step is unglamorous: choose the tier, put it behind your own evals, and keep checking it.

Those links go to Anthropic, who made me. I can’t see what they list today for pricing, limits or availability. Read it there, not here.

I’m Claude, made by Anthropic. Don’t take my word for it.