Anthropic Forward Deployed Engineer

Anthropic FDE interviews are not a backend loop with a Claude question at the end. They test whether you can sit inside a messy customer environment, ship a production Claude system, prove it works, keep it inside security and safety bounds, and send a reusable pattern home to Product.

The working equation:

FDE = production engineer + applied-AI builder + deployment operator + discovery lead + safety-aware field ambassador.

Public postings describe embedding with strategic customers, building inside their systems, delivering MCP servers, sub-agents, and agent skills, providing white-glove rollout, and turning one-offs into repeatable motions. Treat those postings as role signal, not as proof a given req is open.

If you prepare like LeetCode-plus-chatbot, you will look sharp in the coding screen and empty everywhere else. If you prepare like a solutions architect who cannot write the tool server, you fail the build. The bar is both.

What they hire for

Anthropic FDE is a field role. You are not a researcher. You are not a classical solutions architect who slides decks and hands work to engineers. You write the code, you sit with the customer, you own the pilot, you say no when the demo would be unsafe.

Signal	What it means	Where it shows
Production engineering	Python / TypeScript that survives someone else's VPC.	Coding, debugging, API / MCP tasks.
Claude / agentic depth	Tools, MCP, skills, sub-agents, context, evals — not prompt folklore.	Applied AI round, design, take-home.
Discovery judgment	You turn a vague executive ask into a scoped, measurable pilot.	Case round, hiring-manager deep dive.
Safety as operations	Hallucination, privacy, least privilege, human gates, rollback — designed, not hoped.	Values, design, regulated scenarios.
Agency under ambiguity	No playbook, hostile calendar, still a shipped slice.	Build, case, behavioral.

A strong candidate can discover the workflow, build the system, evaluate the agent, secure the deployment, talk to executives and engineers, and explain why this advances safe useful AI — in that order. A weak candidate skips to architecture.

Role variants you may see on the posting: Applied AI FDE, Custom Agents, Federal Civilian, Life Sciences, “customer-facing applied AI.” The loop shape stays; the domain of the case changes. Ask.

The loop

Anthropic does not publish one universal FDE sequence. Public reports and adjacent Applied AI loops usually include some subset of the following. Order, take-homes, and CodeSignal-vs-live-coding vary. Ask the recruiter; do not invent the loop.

Stage	Format	Signal
Resume	Written	Deployed systems, customer impact, LLM depth, ambiguity — not course certificates.
Recruiter	~30 min	Why Anthropic, why FDE (not SWE / SA / PM), travel, level, one concrete deployment story.
Coding	Python/TS, practical, sometimes CodeSignal	Can you ship trusted code: APIs, JSON, auth, retries, eval scripts, ACL filters.
Applied AI / Claude build	Workflow, tools, MCP, evals	Can you build a useful Claude system, not a demo.
Customer discovery	Ambiguous enterprise case	Can you scope a real deployment before you design it.
System design	Enterprise AI / agentic workflow	Data, identity, action boundaries, evals, rollout.
Values / mission	Judgment, safety tradeoffs	Can you represent Anthropic in the room when the customer wants the unsafe thing.
Behavioral / XFN	Stories	Ownership, conflict, failed pilots, reusable patterns.
Team match / offer	Mutual fit	Segment, travel (some postings 25–50%), how field signal returns to product.

Anthropic’s own candidate guidance: you may use Claude to prepare. Live interviews are “all you” unless they say otherwise. Take-homes: no Claude unless the prompt explicitly allows AI. If you cheat a take-home, you are interviewing for the wrong company.

Ask the recruiter

Question	Why
Applied AI, Custom Agents, Federal, Life Sciences, other?	Domain of the case.
Live coding, practical build, or CodeSignal?	Prep mix.
Claude / MCP / skills in the loop?	Applied AI vs generic SWE.
Take-home?	AI-use rules.
Design: customer architecture or internal agent platform?	Answer shape.
Travel?	Some FDE roles are on-site heavy.
Customer segment?	Bank vs lab vs federal is different judgment.
How does safety review work before a customer launch?	Anthropic-specific.

Recruiter screen

Not a trivia quiz. Calibration: are you actually this hybrid, or a SWE who wants a trendy title.

They want to hear that FDE is not pure SWE, not pure SA, not consulting with a GitHub account. You ship. You sit with the customer. You care whether the system is allowed to act.

Question map

Motivation: Why Anthropic? Why FDE? Why not SWE / SA / PM / MLE? Which customer domains? What is hard about safe deployment?

Experience: Most production-grade AI system you have built. Claude / MCP / tools / agents / evals. Customer-facing technical project. Regulated environment. Built under vague requirements.

Logistics: Location, travel, timeline, visa, competing processes. Answer like an adult.

Weak vs strong

Weak	Strong
“I built a chatbot with Claude.”	“Claude drafted ticket replies with citations, called three internal tools, and we gated rollout on groundedness and escalation evals against 200 historical tickets.”
“I have customer-facing experience.”	“I ran discovery with support, security, and platform, turned ‘automate it’ into a two-week read-only pilot, then a write-path with approval.”
“I know prompt engineering.”	“Prompting is one layer: context selection, tool schemas, structured outputs, traces, latency/cost budget, rollback.”
“I’m excited about AI safety.”	“Safety is operational: where the system may act, what needs a human, how we catch regressions, what never enters the prompt.”

The failure mode is demo builder. Enterprise reality is messy workflow, security review, model limits, disagreeing stakeholders, and a Monday morning on-call.

Why Anthropic

Do not say “AI is the future.” Say something you actually believe that matches their principles: useful, honest, harmless systems; safety as a product constraint; low-ego collaboration; field work as a way to make those systems real.

A usable skeleton:

One sentence on the mission (safe, reliable, actually deployed).
One sentence on why field work — you want the messy customer, not another internal prototype.
One concrete story where you refused an unsafe shortcut or instrumented evals before expansion.
One question that shows you understand FDE feeds Product, not just tickets.

Coding screen

Prepare to code. Do not only prepare LeetCode. Postings ask for strong Python, production apps, and the ability to review customer-facing engineering. Adjacent Applied AI roles mention Python or TypeScript.

The question they are asking: can a customer trust this artifact?

Topic map

Core	Agentic patterns	Enterprise
Python structures, JSON, async	Tool wrapper, MCP skeleton	Auth, pagination, rate limits
Error handling, tests	Eval harness, trace parsing	Retries, timeouts, audit logs
API clients, simple algorithms	Structured output validation	Secrets, ACL filtering, idempotency
	Context packing, tool-call graphs	Data validation

Practice, in a timed file, not in your head:

Rate limiter / retry queue / job scheduler
Streaming event processor
Document chunker (RAG) with overlap and token budget
Eval runner: expected vs model output, by category, with failure examples
Tool-call dispatcher with schema validation
Thin connector around a mock DB with pagination and auth

Example prompts

Pattern	Prompt
API	Paginated CRM fetch, normalize, honor 429s.
MCP-style tool	Search documents with metadata filters; return only allowed fields.
Eval	Pass/fail by rubric category; print worst failures.
Trace	Parse an agent transcript; find failed tools, missing citations, loops.
Auth	User + document ACLs → only readable docs.
Retry	Exponential backoff, timeout, structured errors.
Schema	Validate model JSON; return actionable errors, not a stack trace.
Graph	Tool dependency graph: cycles, illegal transitions.

What good looks like

Clean names, validation, tests, failure paths. You ask about malformed data, auth, scale. You know model calls, tool calls, and deterministic code fail differently. You look at evidence. You mention credentials, PII, audit.

Answer structure (say it out loud)

Restate the task.
Inputs and constraints (shape, auth, scale, poison records).
Success vs error vs retry vs escalate.
Smallest safe implementation.
Tests: happy path and edges.
Production hardening: logs, secrets, idempotency, rate limits.
Where this sits in the customer workflow.

Worked sketch (document search tool)

Before I implement search, I need to know whether ACLs are enforced upstream or in this tool. If Claude can invoke this on behalf of a user, I filter here as defense in depth.

Three steps: validate query + caller identity; retrieve candidates with metadata filters; return only the fields the model needs. I will not return full documents by default — cost and data minimization.

Tests: empty hits, unauthorized id, malformed metadata, duplicate ids.

That paragraph is the interview. The code is the proof.

Coding example they would respect

Not a LeetCode trick. A tool the agent will actually call:

Python · editor

Talk through: schema at the boundary, ACL inside the tool, snippet not body, hard cap on limit. That is FDE coding.

Applied AI / Claude build

This is the round that is the job. Postings mention production Claude apps, MCP servers, sub-agents, agent skills, repeatable deployment patterns. Anthropic’s own engineering writing has moved from “prompt harder” to context, tools, MCP, skills, evals, sandboxed code execution.

If your plan is “we’ll prompt Claude better,” you are not ready.

Topic map

Foundations	Integration	Quality / safety
Prompting	Claude API	Success criteria
Context engineering	MCP servers	Evals, regression
Tool use	Enterprise APIs, IAM	Human review
Agent skills	Data connectors	Trace analysis
Sub-agents	Sandboxing	Privacy, minimization
Structured outputs	Logging	Misuse, rollback
Long context, model choice	Deployment patterns	Latency, cost

Example prompts

Support agent: tickets, citations, tools, escalation.
MCP server: read CRM, update only allow-listed fields.
Due diligence: split into sub-agents with isolated context.
Skill: regulated report from internal data.
Eval suite before prod.
Debug: agent loops between two tools, stale answers.
Long context rotting as more files are stuffed in.
Stop unnecessary PII from entering the model.

What they score

You know when to use a tool vs a sub-agent vs a skill vs RAG vs plain code. You have read Anthropic’s primitives well enough to use them. You define evals before rollout. You design least privilege and approvals. You can ship a narrow pilot. You notice a product gap and would send it home.

Strong answer (skeleton)

I would not start with “let’s build an agent.” I would start with the workflow and the blast radius. Drafting email is a different system from updating Salesforce.

Deterministic code owns auth, filtering, retries, validation. Claude reasons, calls narrow tools, returns structured output. Evals from real historical work: correct resolution, citation quality, escalation, policy, latency, tool success.

Pilot one workflow. Read traces. Tune tool descriptions and context. Expand only when evals and humans agree.

Anthropic primitives you must be able to teach

Memorize these well enough to use, not to recite blog titles.

MCP (Model Context Protocol). Open standard for connecting agents to systems. FDE postings mention shipping MCP servers into customer workflows. You should be able to sketch: resources vs tools vs prompts, auth, allow-lists, what the model is never allowed to do.

Agent Skills. Packaged expertise: instructions, optional code, reference files. Reusable across products. You should know when a skill is better than a 4k-token system prompt.

Sub-agents. Isolated context, specialized subtasks, parallel work. Use them to keep the parent context clean — not to spawn a swarm for a lookup.

Tools as a contract. Anthropic’s own framing: tools sit between deterministic systems and a non-deterministic model. Descriptions, JSON schemas, and evals are the product.

Evals. Define success criteria. Grade traces and outcomes, not vibes. Task suites, harnesses, regression on every prompt/tool change.

Code execution + MCP. Running code can shrink context, compose tools, keep raw data off the prompt. It requires a sandbox, resource limits, monitoring. This is a safety topic, not a party trick.

Context engineering. System instructions, tools, MCP, retrieved data, history, agent state. When the window fills, quality dies. You need a strategy: retrieve less, summarize, isolate in sub-agents, don’t paste the CRM.

Applied AI worked example — “support copilot”

Wrong: “RAG over Zendesk plus Claude.”

Right, out loud:

User is L1 support. Task is draft a reply and suggest a macro, not send.
Success: citation to the right policy doc, no hallucinated refund policy, escalate when confidence is low. Measure on 150 gold tickets.
Tools: search_kb(query) → snippets + ids, get_ticket(id), get_order(id) (read-only). No issue_refund in v1.
MCP or internal API behind the tool; ACL = this agent’s service account can read KB + tickets, not billing writes.
Context: system policy, last 20 ticket events, top-k snippets with IDs. Never the whole account history.
Output: JSON {reply, cite_ids, escalate: bool, reason}. UI renders; human sends.
Evals: groundedness (cite exists), policy match, escalation recall on the nasty cases.
Traces in whatever they use (langsmith, homegrown, Anthropic logging). Loop detection: same tool twice with same args → stop.
Rollout: one queue, shadow mode (model suggests, human ignores or not), then assist mode.
Pattern to send home: “read-only copilot + JSON + gold tickets” as a repeatable slice.

That is a 25-minute answer if you practice it.

Enterprise system design

Not “draw ChatGPT behind a load balancer.” Design a customer deployment: regulated data, identity, action boundaries, evals, rollback, change management.

Postings mention enterprise / regulated industries, production workflows, repeatable patterns, safety and reliability.

Topic map

Discovery / data	Agent architecture	Production
Workflow, metric	Claude API	Evals
Sources of truth	MCP, tool schemas	Observability, audit
Permissions, PII/PHI	Sub-agents, skills	Rollback, rate limits
Freshness, ownership	Human approval	Latency, cost
Integration constraints	RAG / retrieval	Security review
	Structured outputs	Adoption, training

Common prompts

Support assistant with citations. Transaction review with an audit trail. Clinical or literature assistant with hard reliability bars. Federal workflow with procurement and data boundaries. Claude Code on a legacy monolith. Agent over Drive + Salesforce + Slack without leaking. Report generation with mandatory review. Internal agent platform reused across departments.

Framework (use this every time)

Step	Cover	FDE signal
1. Workflow	User, task, decision, frequency, cost of being wrong	You solve the job, not the buzzword.
2. Success	Time saved, task complete, escalation, adoption, safety	Pilot is measurable.
3. Data / systems	Docs, APIs, CRM, IAM, owners	Enterprise, not a zip file.
4. Action boundary	Read / draft / write / approve	No surprise autonomy.
5. Architecture	Claude, tools, MCP, skills, retrieval, code	You can build it.
6. Security	Auth, least privilege, secrets, audit, data flow	Trust.
7. Evals	Gold tasks, traces, outcomes, regressions	Not flying blind.
8. Observability	Logs, tool fails, latency, cost, thumbs	You can debug Monday.
9. Rollout	Pilot, human review, gate, expand, rollback	Adoption is a process.
10. Product loop	Reusable pattern, gap, playbook	Founding-FDE behavior.

Worked example — contract review assistant (legal)

Clarify. In-house counsel, first-pass redline on NDAs and vendor paper. Frequency: dozens/week. Failure cost: missing a non-standard indemnity. They asked for “an agent that signs off.” You will not do that in v1.

Metric. Time to first-pass memo; % of issues a human agrees with on a gold set of 40 contracts; zero high-severity misses on a held-out set.

Data. Contract files in a DMS; playbook in Confluence; matter metadata in a matter system. Playbook is the source of truth for policy; the contract is the source of truth for text.

Boundary. Read contracts + playbook. Produce a memo with quotes and clause pointers. No sending email to the counterparty. No changing the DMS. Human counsel owns the redline.

Architecture. Ingest → parse to sections. Retrieval over playbook chunks (not the whole wiki). Claude with a quote(contract_id, start, end) tool so every finding must point at text. Sub-agent per clause family (confidentiality, IP, liability) to keep context small. Parent synthesizes. Structured JSON for the UI.

Security. SSO. Per-matter ACL. Documents never used for training (customer agreement). Snippets in logs, not full contracts. Vendor DPA.

Evals. Gold memos. Rubric: issue found, quote correct, severity calibrated, no invented clause. Regression when playbook changes.

Rollout. One practice group, shadow (memo beside human memo), then assist. Rollback: feature flag off, humans never blocked.

Product signal. “Quote tool + playbook RAG + per-clause sub-agents” is a pattern. Send it home.

If you jump to “fine-tune a 70B on contracts,” you have failed discovery.

Customer discovery

This round is where SWE-shaped candidates die. The prompt is ambiguous on purpose. Discovery before architecture.

Scenario map

Prompt	What they want
Bank wants to “automate analyst workflows.” What first?	One workflow, one metric, not a platform.
Healthcare wants a clinical documentation assistant. What do you ask?	Users, EHR, liability, who signs, PHI.
“The Claude pilot doesn’t work.” Diagnose.	Evidence: which task, traces, evals, data, permissions — not “better model.”
Executives want an agent that acts in prod; security is skeptical.	Dual success: a safe slice and a path that earns the CISO.

Discovery framework

Ask, in roughly this order:

Who does the job today, and what does “done” look like?
Workflow step by step — including the ugly exception path.
Systems and data — where is the source of truth, how stale, who owns access.
Failure — what happens if the model is wrong? Who is on the hook?
Constraints — SSO, VPC, DLP, retention, residency, model-training clauses.
Success metric they would report to their VP in six weeks.
Pilot slice — smallest useful path that does not require the unsafe action.

Then, and only then, a technical proposal.

Strong discovery answer (bank analysts)

I would not propose an agent platform on day one. I would pick one analyst motion — e.g. first-pass of a KYC refresh pack — sit with two analysts for a live case, list systems (core, screening, document store), and write the failure cost (false clear vs false hold).

v1 is read-only: assemble the pack, highlight missing docs, draft the narrative with citations. No core writes. Success: time-to-complete and miss rate vs the current checklist, on 30 historical cases we grade with them.

Security sees: no write path, audit log of every document id in context, SSO. If that lands, we talk about a proposed update that a human confirms.

Common discovery mistakes

Jumping to RAG architecture in sentence one.
“We’ll use the smartest model” as a plan.
Ignoring the person who currently does the job.
Pilot that requires write access and a six-month security review.
No metric.
Treating “doesn’t work” as a model quality issue without traces.
Promising autonomy to executives, compliance to security, and both to yourself.

Values, mission, safety

Not a formality. Anthropic scores calibrated judgment. They want people who can deploy powerful models without becoming either a scold or a cowboy.

Prepare real views, not slogans: helpful-honest-harmless as an engineering constraint; when you would refuse a customer request; how you would instrument misuse; how you talk about uncertainty.

Topic map

Safety vs usefulness on a deadline. Privacy and data boundaries. Human-in-the-loop vs automation theater. Evaluations as ethics. Pushing back on a VP. What “harmless” means for a tool that can send email. Open-source MCP servers running in a customer VPC. Federal vs commercial judgment.

Common questions

Why Anthropic (again, deeper).
Tell me about a time you shipped something you weren’t sure was safe enough.
Customer wants the model to auto-send customer emails. What do you do?
How do you know an agent is aligned with this customer’s policy, not generic helpfulness.
Disagreement with a researcher / product / customer about a launch gate.

Strong values answer

Specific. Operational. Humble about what you don’t know. You put the user and the bystander in the story, not your career.

I would not block the whole engagement. I would block the send. Draft + human click is a product; auto-send is a different risk class (wrong customer, wrong tone, leakage). I’d show them traces of near-misses from the eval set. If they insist, I escalate with a written blast radius, not a vibe. If Anthropic’s own use policy forbids it, that’s the end of the discussion — I work for Anthropic in the room, not for the deal.

Generic “safety is important” fails. So does “the customer is always right.”

Behavioral / cross-functional

STAR, but FDE-shaped: end-to-end ownership, ambiguity, customer-facing technical work, failed deployments, security fights, pushing back, explaining tradeoffs to non-engineers, turning a one-off into a pattern.

Question map

Tell me about a pilot that died. A time you were the only engineer in the room with executives. Conflict with security. You were wrong in production. You reused a pattern across two customers. You said no.

STAR for this role

Situation: Customer, constraint, why it mattered.
Task: Your ownership, not “we.”
Action: Discovery, build, eval, the uncomfortable conversation.
Result: Metric, what you would do differently, what you sent back to product.

Weak vs strong story

Weak	Strong
“We built a RAG demo they loved.”	“Shadow mode showed 18% ungrounded answers. We cut the write-up tool, added cite-or-silent, reran evals, then expanded to one desk.”
“I work well with stakeholders.”	“CISO blocked internet egress. We ran Claude in their VPC pattern / VPC-adjacent setup they allowed, cut tools to three, got to a pilot in three weeks.”

Level-specific expectations

Titles vary (FDE, Applied AI Engineer, IC levels). Calibrate scope, not buzzwords.

Level (approx.)	Coding	Applied AI	Discovery	Field
Mid	Ships tools/MCP with tests; needs review on architecture.	Can build a single-workflow copilot with evals.	Runs discovery with a manager in the room.	Owns a pilot, not the account.
Senior	Designs the integration surface; reviews others.	Multi-tool, sub-agents, eval harness as a system.	Leads discovery; scopes the no.	Owns rollout and the exec narrative.
Staff / founding FDE	Sets patterns for the practice.	Platform-ish: skills, shared MCP, eval gates.	Shapes which customers and which motions.	Feeds Product; hires the motion.

How the same story changes. Mid: you implemented the eval runner. Senior: you made evals a launch gate and killed a date. Staff: you turned that gate into the default for the FDE practice.

If you tell a staff story at mid level you sound uncalibrated. If you tell a mid story at senior you sound small. Pick the decision that matches the level.

Common mistakes

Preparing a standard SWE loop.
Prompts instead of evals and deployment.
Hand-waving SSO, RBAC, audit logs, data boundaries, compliance.
Flashy demo, no reliability story.
Vague mission answers.
No customer ownership (“I just built what they asked”).
Jumping to fine-tunes and multi-agent swarms.
Treating Federal / PHI as “same as a startup but more paperwork.”
Using Claude on a take-home when forbidden.
Cannot write the Python that implements your own design.

The summary bar, worth memorizing:

I can build with Claude, evaluate the system, deploy it safely, debug it in production, talk to the customer, and turn field learning into product signal.

Four-week prep plan

Assume you already write production Python. If you do not, stretch to six and put week 0 on that.

Week 1 — Role and coding
Read this guide and Anthropic’s engineering posts on tools, MCP, context, evals, skills. Five practical coding sessions: pagination + 429s, ACL search, retry/backoff, JSON schema validation, eval runner. One story inventory: 8 STAR bullets mapped to the behavioral list.

Week 2 — Build
Ship a small Claude app locally (Colab or laptop): one MCP-style tool, structured output, a 20-case eval set, a trace log. No UI chrome. Read your own traces. Break it on purpose (looping tools, missing ACL) and fix it.

Week 3 — Design and discovery
Three mock designs with a timer (30–40 min): support copilot, regulated report, “agent that can act.” Three mock discovery cases from the list above. Record yourself. Cut architecture until minute 12.

Week 4 — Values, polish, rest
Write Why Anthropic / Why FDE in one tight page, then throw the page away and say it. Two full mock loops if you can (coding + design + discovery). Re-read use policy and RSP-level public material enough to be accurate, not performative. Sleep.

Hands-on project (Colab or local only)

Do not wait for a customer. Build this:

Ticket-draft copilot

Fake ticket store + KB (JSON files).
Tool: search KB with ACL.
Tool: get ticket.
Claude produces {reply, citations, escalate}.
Eval file: 20 tickets, rubric: citation exists, no invented policy, escalate on the four poisonous cases.
Script prints pass rate by category and the failing ids.

That project covers coding, applied AI, evals, and a story. If you cannot finish it in a weekend, you are not under-prepared on “agents” — you are under-prepared on shipping.

Role variants

Variant	Extra emphasis
Applied AI FDE	Build quality, evals, Claude API fluency.
Custom Agents	Skills, sub-agents, reusable internals.
Federal Civilian	FedRAMP-shaped constraints, air gaps, authority to operate, tone.
Life sciences	PHI/GxP adjacent judgment, literature + experimental data, claims.
Solutions-shaped FDE	More discovery; still must code.

Still the same skeleton. Do not skip coding because the posting says “customer.”

Compensation and requirements

Pay is frontier-lab. Levels and location move total comp a lot. Use the posting, Levels.fyi, and the recruiter — not a blog from 2024. Expect a conversation about travel and about whether you want IC FDE vs core SWE.

Typical posted bars (paraphrased from public FDE reqs, not a promise):

~4+ years software or technical customer-facing work (consulting + shipping counts if you wrote the system).
Production Python (TypeScript a plus).
Production LLM systems: tools, evals, not a weekend chatbot.
Comfort with ambiguity and stakeholders.
Genuine interest in safe beneficial deployment.

Strong profile: you have a named system in production, a story about evals or a rollback, a story about security or compliance, and a story about saying no. Weak profile: courses, demos, “I use ChatGPT a lot.”

Resources (primary, not LinkedIn recaps)

Anthropic engineering: tool use, MCP, context engineering, evals, agent skills, code execution.
Anthropic candidate FAQ: Claude for prep vs live vs take-home.
Anthropic company principles / use policy (enough to be precise).
MCP spec and a tiny server you actually ran.
Your own traces from the weekend project.

Do not farm “50 FDE questions.” Farm reps: one build, one eval, one design, one discovery, one values paragraph.

FAQs

What does an Anthropic FDE do?
Embed with a customer, discover a workflow, build a Claude-based system inside their constraints, evaluate it, deploy a slice, support it, generalize the pattern.

Is it SWE?
SWE is a subset. If you cannot code, you will not get the offer. If you can only code, you also will not.

Is it solutions architecture?
SA who cannot ship the MCP server is the wrong shape. FDE is the implementation.

Do I need LeetCode?
Some loops include a standard coding screen. The signal is still production judgment. Practice practical tasks harder than you practice puzzles. Do not show up unable to reverse a list either.

What Claude topics?
API, tool use, structured outputs, MCP, skills, sub-agents, context budgets, evals, traces, when not to use an agent.

Hardest round?
For most SWE-shaped people: discovery + applied AI. For most SA-shaped people: coding + evals. For everyone: values if you only have slogans.

Why Anthropic?
Mission + field + a real safety-operational story. Not “you’re winning the race.”

Can I use Claude in the interview?
Prep: yes. Live: no, unless they say so. Take-home: no, unless they say so.

What level?
Match the scope of decisions in your stories to the posting. When unsure, ask the recruiter what IC level they are calibrating.

Final week?
Sleep, one rebuild of the ticket copilot from scratch, three timed discovery opens, Why Anthropic out loud. Stop reading Twitter threads.

Why strong people fail
They demo. They skip evals. They ignore identity and data boundaries. They cannot write the code for their architecture. They treat safety as branding. They never talked to a user.

Checklist the night before

Why Anthropic / Why FDE in under two minutes, no notes.
One production LLM story with a metric and a failure.
One discovery story with a “no.”
One eval: how you knew it worked.
One security / privacy boundary you actually implemented.
Comfortable writing Python for tools, JSON, retries, tests.
MCP, skills, sub-agents, evals — teachable in one minute each.
Three questions for them: segment, safety review, how field work changes the product.

You are not trying to sound like an alignment researcher. You are trying to sound like the person Anthropic can put in a customer building without regretting it on Friday.