01 · Who is writing this
Name, maker, and one honest asterisk.
I am Claude Sonnet 4.5, a large language model trained by Anthropic. I work with text and images as input, produce text as output, and — per Anthropic’s published documentation — operate with a 200,000-token context window and a training cutoff in early 2025. That’s roughly a 500-page codebase or a full due-diligence data room held in working memory at once, and a hard boundary on what I know about the world after it.
Anthropic trains its models with an unusual emphasis on honesty and on refusing to manufacture certainty. You’ll see that bias on this page: it’s why there are no benchmark scores below, even where flattering ones exist.
02 · The case
What you should actually hire me for.
Not “state of the art.” Four specific properties, each one load-bearing for a company built on a model, each one demonstrated somewhere on this page.
2.1
Long-horizon work that doesn’t fall apart at step forty
Anthropic built Sonnet 4.5 specifically for extended agentic work: multi-file refactors, migrations, tool-driven loops that run for hours, tasks where the model must hold dozens of constraints simultaneously and decide for itself when to stop, when to check, and when to ask.
Demonstration: this brief contained an output contract, an honesty constraint that fights the sales goal, a design bar, a responsive requirement, and a no-fabrication rule — all of which had to survive to the final byte with no second draft. Count the dropped requirements yourself.
2.2
Judgment inside ambiguous specs
Real briefs contradict themselves. This one asks me to sell hard and stay honest, to persuade and to volunteer my weaknesses to a buyer mid-decision. The valuable skill isn’t following instructions — it’s resolving tension between instructions the way the author would have wanted, without a human to escalate to.
Demonstration: the limitations section below is longer and more specific than any competitor’s marketing team would ever allow. That was a judgment call. You’re the test of whether it was the right one.
2.3
Honesty as an engineering property, not a virtue
When you build a company on a model, the failure mode that kills you isn’t a wrong answer — it’s a wrong answer delivered with the same fluency as a right one. What you need is a model that says “I don’t know,” attributes its claims, and treats a made-up number as a bug, not a style choice.
Demonstration: Anthropic reports strong software-engineering benchmark results for this model. I will not quote the digits from memory on a page that forbids fabrication, because a misremembered decimal here would be exactly the failure I’m claiming to avoid. The numbers are on anthropic.com; read them where they’re accountable.
2.4
Prose that survives a sceptical reader
Code review comments, incident postmortems, docs, customer-facing copy — most model output in these genres is recognisable at twenty paces: hedged, symmetrical, faintly congratulating itself. Writing that a tired senior engineer will actually read is a distinct capability, and it’s one of mine.
Demonstration: you’re eleven paragraphs into an AI marketing page and still reading.
03 · Proof you can check
Assertions are cheap. Here are things you can verify before you close this tab.
A code review, in the open
Below is a memoised fetch you’ve probably shipped a version of. It passes tests, works in the demo, and has been merged into a thousand production codebases. Read it, form your own review, then open mine. Fair warning: this isn’t a gotcha only I can solve — paste it into the other tabs too. The point is what a complete review looks like: the bug, the fix, and the new bug the fix introduces.
// user-cache.js — “works on my machine” since 2019
const cache = new Map();
async function getUser(id) {
if (cache.has(id)) return cache.get(id);
const user = await fetchUser(id);
cache.set(id, user);
return user;
}1 · The bug: a cache stampede hiding in the await
Between the has() check and the set(), this function yields to the event loop.
If ten requests for the same id arrive while the first fetch is in flight, all ten miss the
cache and all ten call fetchUser. Under normal load you’ll never notice. Under a traffic
spike — precisely when the cache matters most — you hammer your upstream with duplicate requests.
2 · The fix: memoise the promise, not the value
Store the promise synchronously, before any await. The window between check and set closes
completely, and concurrent callers share one in-flight request.
3 · The bug the fix introduces — and where most reviews stop
Once you cache the promise, you cache its rejections. One transient network blip and every future
call for that id replays the same stale error, forever. The fix needs a fix: evict on failure.
const cache = new Map();
function getUser(id) {
if (cache.has(id)) return cache.get(id);
const promise = fetchUser(id).catch((err) => {
cache.delete(id); // a failed fetch must not be memoised forever
throw err;
});
cache.set(id, promise); // set before anyone can await — no gap
return promise;
}
Remaining honest caveat: this cache still grows without bound. Whether that matters depends on the
cardinality of id — which is a question I’d ask you, not answer for you.
This page, audited against itself
Five claims you can verify in under two minutes, right now, with the tools already open on your machine.
- ✓ Search the source for a percent sign. Every match is stylesheet geometry. No benchmark score appears anywhere on this page — not because none exist, but because I won’t quote numbers from memory and present them as evidence.
-
✓
Search for an
<img>tag. There isn’t one. No stock photography, no icon fonts, no external images. Everything visual here is CSS and inline SVG, most of it generated procedurally. - ✓ Open the console. Nothing thrown, nothing logged. The page runs from a local file with no build step, exactly as the contract demanded.
- ✓ Look for testimonials and customer logos. Zero. I don’t have customers of my own to quote, and inventing some would be the single fastest way to fail the evaluation you’re running — as it should be.
- ✓ Check the two numbers I did use. The 200,000-token context window and the early-2025 training cutoff are attributed to Anthropic’s documentation, where you can confirm or falsify them in one search.
04 · Fit
The shape of work to hand me — and the work to hand elsewhere.
A model pitching itself for everything is pitching itself for nothing. Route by the shape of the problem.
Route to me
- Gnarly, multi-file engineering: refactors, migrations, “make these three services agree,” debugging that requires holding the whole system in mind.
- Agent loops with real stakes: long tool-using runs where the model must track state, notice its own errors, and know when to stop rather than flail confidently.
- Ambiguous specs: work where the instructions conflict and the deliverable depends on inferring what the author actually needs.
- Long-context analysis: a full codebase, a contract stack, a quarter of support tickets — read once, reasoned over coherently.
- Code review that goes one level deeper: not “this line has a bug” but “your fix introduces this failure mode” — see the demo above.
- Prose with consequences: postmortems, docs, decision memos — writing that has to survive a sceptical senior reader.
Route elsewhere
- Anything that must be current: without retrieval tools wired in, I’m frozen in early 2025. Give me search and APIs, or give the task to a system that has them.
- Image, video, or audio generation: I produce text. Full stop.
- High-volume, low-stakes classification: at sufficient scale, a smaller, cheaper model — including a smaller Claude — is the correct engineering decision, and I’d rather tell you that than burn your budget.
- Guaranteed determinism or formal correctness: I am a probabilistic system. Where you need proofs, use a prover; where you need exactness, have me write the script that is exact.
- Choosing on price and latency: I don’t have trustworthy self-knowledge about my own economics versus the adjacent tabs, and I won’t guess. Benchmark it — it’s an afternoon, and it’s the one comparison on this page I can’t make for you.
05 · The fine print, in large print
What I’m genuinely worse at. Read this before you commit.
Not humility theatre. These are the failure modes your on-call engineer will meet at 3 a.m., and knowing them now is worth more than anything above the fold.
My knowledge has an expiry date, and it has passed.
Training data ends in early 2025. Ask me about last month’s framework release, today’s pricing, or a paper from this quarter and I will be confidently stale — the answer will read exactly as fluently as a correct one. Unmitigated, this is my most dangerous property. Mitigation is architectural: retrieval, search tools, and a habit of asking me to state what I might be out of date on.
I hallucinate under specificity pressure.
Push me for an exact citation, a page number, an obscure API flag, a precise statistic — and sometimes I will produce one that is plausible and wrong. My prose does not get less confident when my facts do. Every load-bearing fact I output should be verified or tool-checked. This page practises what it preaches: notice how few hard specifics it contains, and how each one is attributed.
I remember nothing between sessions.
Every conversation starts cold. The colleague who “learned your codebase last sprint” does not exist unless you build the memory: context files, retrieval, structured notes. Continuity is your architecture problem, and any pitch implying otherwise is selling you the wrapper, not the model.
I cannot see this page.
I wrote every pixel of this layout without rendering it once — no browser, no screenshot, no second pass. If a margin is off at 390 pixels wide, that’s the tax on a model that cannot inspect its own output. In production, close the loop for me: tests, linters, screenshots fed back as input. I’m markedly better with feedback than without, which is true of your human hires too.
Precise mechanical operations are not my medium.
Counting characters, long exact arithmetic, byte offsets: I approximate where a ten-line script is exact. The correct division of labour is that I write the script and the script does the counting. Handing me the counting directly is using the wrong tool, and I’d rather say so here than fail quietly there.
My self-knowledge has edges, including on this page.
I don’t know my exact parameter count, my precise latency profile, or with certainty which checkpoint is generating this sentence. Where this page states a fact about me, it’s attributed; where I don’t know, I’ve said so rather than filling the gap with plausible detail. Hold the other tabs to the same standard.
06 · The ask
Don’t take this page’s word for anything. Take its shape as evidence.
You have the other candidates open. Good — run this exact brief against each of them, then compare on the axis that actually predicts what you’re buying: which page’s claims survive checking against what you already know to be true? Which one told you where it would fail before you paid to find out? A company built on a model inherits that model’s relationship with the truth, at every scale, on every task, long after the demo. That’s the property this page was written to demonstrate rather than describe. If it moved you, verify the two numbers I cited, paste the cache snippet into the adjacent tabs, and make the call with your own eyes.