AI-Native Engineering for Forward Deployed Engineers
Applies to: every engineer who ships with a coding agent in a client codebase · Time to learn: 30 min reading + 15 min self-assessment · Lever: context, feedback, and guardrails (all three)
A forward deployed engineer (FDE) lands in an unfamiliar codebase, learns it fast, and ships. Coding agents can multiply that speed, but only when you set them up well. This section gives you the shortest path: a small set of habits, files, and tools that work with Claude Code, OpenCode, Codex, and any other harness.
- An agent is only as good as (1) the context it gets, (2) the feedback loop it can run, and (3) the guardrails around it.
- Keep sessions short and focused: one task per session,
/clearbetween tasks, plan before code. - Give the agent a way to check its own work (tests, linter, build, screenshot) before you review.
- Put what must always happen in hooks and CI. Put what the agent should know in
AGENTS.md, skills, and MCP. - Use the maturity ladder at the end of this page to pick your next step.
Why it matters in the AI age
What an FDE does
There is no single standard definition, so this section uses a working one synthesized from two job postings. Anthropic describes its Forward Deployed Engineer as someone who "embeds directly with our most strategic customers to drive transformational AI adoption." OpenAI describes FDEs as leading "complex end-to-end deployments of frontier models in production alongside our most strategic customers," owning discovery, scoping, design, build, and rollout. Working definition: a post-sale engineer who embeds with a customer, builds and ships production systems inside the customer's environment, and feeds field findings back to the product. (Sources: see below.)
How agents change the job
| Without an agent | With a well-set-up agent |
|---|---|
| Days reading an unfamiliar codebase before the first change | Agent explores in a separate context and returns a summary (see Context Engineering) |
| Client conventions live in people's heads | Conventions live in AGENTS.md and rules the agent reads every session (see AGENTS.md, CLAUDE.md, and Rules) |
| You run the tests, read the output, fix, repeat | The agent runs the loop and you review a verified diff (see The Agent-Ready Toolchain) |
| Risky commands depend on your attention | Permissions and hooks block them every time (see Hooks, Pre-commit, and Quality Gates) |
The job shifts from typing code to specifying, verifying, and steering. Those skills are what this section teaches.
Core concepts
The three levers
| Lever | Question it answers | What you control | Home pages |
|---|---|---|---|
| Context | Does the agent know what it needs, and only that? | Session scope, AGENTS.md, memory, plans, skills, MCP servers | Context Engineering, AGENTS.md, Memory, Skills, MCP |
| Feedback loop | Can the agent tell if it is right? | Tests, linters, type checks, build, fast deterministic tools | Toolchain, Execution Plans |
| Guardrails | What happens when the agent is wrong or manipulated? | Permissions, hooks, pre-commit, CI, least-privilege MCP | Hooks and Quality Gates, MCP |
The agent loop
Read the diagram as three questions you can ask about any bad result. Was the context missing or crowded (left side)? Could the agent verify (bottom)? Was something allowed that should have been blocked (guardrails)?
Anthropic's own guidance points the same way: the Claude Code best-practices page states that "Claude's context window fills up fast, and performance degrades as it fills," and recommends giving Claude a way to verify its work and using hooks for actions that must happen every time.
How to read this section
Pages build on each other, so read them in order. Times are our estimates for reading plus the exercise.
| # | Page | You will learn | Time |
|---|---|---|---|
| 1 | This page | The three levers, exam map, habits, maturity ladder | 45 min |
| 2 | Context Engineering | Why long sessions get worse, and how to keep sessions focused | 45 min |
| 3 | AGENTS.md, CLAUDE.md, and Rules | What goes into project instructions and what stays out | 45 min |
| 4 | Scratchpads, Memory, and Markdown Knowledge Bases | How to keep knowledge across sessions | 45 min |
| 5 | Execution Plans | How to go from epic to verified change with plan files | 60 min |
| 6 | Skills and Skill Creation | How to package a repeatable procedure as a skill | 60 min |
| 7 | MCP Servers | When to add an MCP server, which ones, and how many | 45 min |
| 8 | Hooks, Pre-commit, and Quality Gates | How to enforce what must always happen | 60 min |
| 9 | The Agent-Ready Toolchain | Why fast, deterministic tools make agents better | 45 min |
| 10 | Agent Harnesses | How to choose a harness and stay harness-agnostic | 30 min |
| 11 | Lab: Make a Repository Agent-Ready | Apply everything to one real repo | 90 min |
If you have one hour only: read the cheat sheet below, then pages 2 and 3.
Claude Certified Architect – Foundations
The Claude Certified Architect – Foundations (exam code CCAR-F) is Anthropic's first technical certification, announced on 2026-03-12 for partners. The certification page says it tests "foundational knowledge across Claude Code, the Claude Agent SDK, the Claude API" and MCP. This section is not exam prep, but it covers the practical skills behind most of the domains.
Exam facts (as of 2026-10)
| Item | Value |
|---|---|
| Format | 60 items, multiple choice and multiple response |
| Scenarios | 4 scenarios drawn at random from a pool of 6 |
| Duration | 120 minutes, proctored |
| Scoring | Scaled 100 to 1000, passing score 720 |
| Price | $125 USD |
| Delivery | Pearson VUE (moved there on 2026-06-30) |
| Validity | 12 months from the date earned |
| Retakes | 14 days after the first failure, 30 days after the second, 90 days after the third; maximum 4 attempts in a rolling 12 months |
Eligibility is tied to Claude Partner Network membership; check the FAQ for the exact rule.
Domains, weights, and where to learn them
Domain names below are reconstructed from the exam guide PDF, whose text layer decodes imperfectly. Check the official exam guide linked in Sources for the exact wording before you quote them.
| # | Domain | Weight | Pages in this section | Existing pages |
|---|---|---|---|---|
| 1 | Agentic Architecture & Orchestration | 27% | Execution Plans (subagents, parallel work), Hooks and Quality Gates (human-in-the-loop), Agent Harnesses | Agentic AI Platforms covers agent architecture and workflow patterns |
| 2 | Tool Design & MCP Integration | 18% | MCP Servers, Skills | Agentic AI Platforms covers MCP in client systems |
| 3 | Claude Code Configuration & Workflows | 20% | AGENTS.md, CLAUDE.md, and Rules, Skills, Execution Plans (plan mode), Hooks and Quality Gates, Agent Harnesses | none |
| 4 | Prompt Engineering & Structured Output | 20% | Partial: Execution Plans (writing precise task specs), Context Engineering | Agentic AI Platforms for schema-checked outputs in agents; use Anthropic's API docs for structured output |
| 5 | Context Management & Reliability | 15% | Context Engineering, Memory and Knowledge, Hooks and Quality Gates | Agentic AI Platforms for reliability patterns |
Domain 3 is the one this section covers most directly (the guide's exercises include CLAUDE.md files, .claude/rules/ with path-specific rules, project skills, plan mode, and MCP configuration in .mcp.json). Domain 4 is only partly covered: the section teaches how to instruct a coding agent, not how to design API prompts and JSON schemas.
Anthropic lists these prep courses: AI Fluency: Framework & Foundations, Building with the Claude API, Claude Code in Action, Claude 101, Claude with Amazon Bedrock, Claude on Google Cloud, and Introduction to Model Context Protocol.
The one-screen cheat sheet
| # | Habit | Lever | Details |
|---|---|---|---|
| 1 | One task per session; /clear between unrelated tasks | context | Context Engineering |
| 2 | After two failed corrections, /clear and write a better prompt | context | Context Engineering |
| 3 | Send research to a subagent so it does not fill your main context | context | Context Engineering |
| 4 | Check what loads before you type (/context) | context | Context Engineering |
| 5 | Keep AGENTS.md short; test each line: would removing it cause mistakes? | context | AGENTS.md, CLAUDE.md, and Rules |
| 6 | AGENTS.md is the source of truth; CLAUDE.md imports it | context | Agent Harnesses |
| 7 | Scope rules to paths so they load only when needed | context | AGENTS.md, CLAUDE.md, and Rules |
| 8 | Keep a scratchpad for the current task and notes for the next session | context | Memory and Knowledge |
| 9 | Explore, then plan, then implement, then commit | context + feedback | Execution Plans |
| 10 | Write one plan file per slice of an epic, with a verification step each | feedback | Execution Plans |
| 11 | Run parallel work in separate git worktrees | feedback | Execution Plans |
| 12 | Give the agent a way to verify: tests, linter, build, screenshot | feedback | Toolchain |
| 13 | Pin tool versions with mise so the agent and CI run the same tools | feedback | Toolchain |
| 14 | Turn a procedure you paste twice into a skill | context | Skills |
| 15 | Add an MCP server only for a clear need; keep the list short | context | MCP Servers |
| 16 | Pin MCP server versions and grant least privilege | guardrails | MCP Servers |
| 17 | Use hooks for what must always happen; rules are advisory | guardrails | Hooks and Quality Gates |
| 18 | Run format and lint after every edit, and again in pre-commit and CI | guardrails + feedback | Hooks and Quality Gates |
| 19 | Ask a fresh-context reviewer subagent to check the work before you do | feedback | Execution Plans |
| 20 | Check the client's approved providers and data rules before choosing a harness | guardrails | Agent Harnesses |
The maturity ladder
| Level | Name | What it looks like | Add this to move up |
|---|---|---|---|
| 0 | Chat in a browser | You paste code into a chat window and copy answers back | Install a harness in the repo (see Agent Harnesses); let it read files and run commands |
| 1 | Agent in the repo | The agent edits files and runs commands, with no project instructions | A short AGENTS.md with build, test, and style commands (AGENTS.md); the /clear habit (Context Engineering) |
| 2 | Agent with context and a feedback loop | AGENTS.md, scoped rules, and a one-command test, lint, and build; the agent verifies its own work | Plan files for non-trivial work (Execution Plans); skills and a few MCP servers (Skills, MCP) |
| 3 | Planned work with guardrails | Plan mode before code, execution plans per slice, permissions set, hooks run format and lint | Hooks, pre-commit, and CI gates the agent cannot skip (Hooks and Quality Gates); pinned toolchain (Toolchain) |
| 4 | Parallel agents with enforced gates | Several agents work in worktrees on separate plans; gates block bad changes; a reviewer agent checks results | Keep tuning: remove scaffolding the model no longer needs; track which gates catch real problems |
Anthropic's harness-design post gives a useful rule for level 4: "Every component in a harness encodes an assumption about what the model can't do on its own," so re-test your scaffolding as models improve.
Try it
Lab 15-minute self-assessment of one repo
- Pick a repo you work in now. Open a fresh agent session in it and ask: "Which commands build, test, and lint this project?" If the answer is wrong, you are at level 1 or below.
- Run
/context(Claude Code) or the equivalent and note what loads before you type anything. Is any of it unneeded? - Check for the files:
AGENTS.md,.claude/rules/,.claude/skills/,.mcp.json,.claude/settings.json, a pre-commit config, amise.toml. - Ask the agent to make a small change and watch: does it run tests and lint on its own? Can it fail without anyone noticing?
- Place the repo on the ladder using the table above. Write down the single next row item you will add this week.
- When you are ready, do the full exercise in Lab: Make a Repository Agent-Ready.
Checklist
- I can state the three levers and name one example of each in my current repo.
- I know which page to open for context, feedback, and guardrail problems.
- I placed my current repo on the maturity ladder (0 to 4).
- I picked one next step and a date to do it.
- I know the CCA domains and where this section covers them.
- I checked the official exam guide if I plan to sit the exam.
Sources
- Forward deployed engineer, Anthropic posting: https://job-boards.greenhouse.io/anthropic/jobs/5391016008 and index https://www.anthropic.com/careers/jobs
- Forward deployed engineer, OpenAI posting (search snippet): https://openai.com/careers/forward-deployed-engineer-sf-san-francisco/
- Claude Certified Architect – Foundations certification page: https://anthropic-partners.skilljar.com/claude-certified-architect-foundations-certification
- Certification FAQ (price, Pearson, retakes, dates): https://anthropic-partners.skilljar.com/page/faq-certifications
- Prep courses: https://anthropic-partners.skilljar.com/page/claude-certified-architect-foundations-prep-courses
- Launch announcement (2026-03-12): https://www.anthropic.com/news/claude-partner-network
- Exam guide PDF (format, domains, weights; version 1.0): https://everpath-course-content.s3-accelerate.amazonaws.com/instructor%2F6nizmqk8tpzpfjvt6qmmav7rh%2Fpublic%2F1783542750%2FClaude+Certified+Architect+%E2%80%93+Foundations+Exam+Guide.pdf
- Claude Code best practices: https://code.claude.com/docs/en/best-practices
- Claude Code memory (CLAUDE.md size, rules, hooks vs rules): https://code.claude.com/docs/en/memory
- Claude Code context window: https://code.claude.com/docs/en/context-window
- Claude Code worktrees: https://code.claude.com/docs/en/worktrees
- Building effective agents: https://www.anthropic.com/engineering/building-effective-agents
- Effective context engineering for AI agents: https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
- Harness design for long-running apps: https://www.anthropic.com/engineering/harness-design-long-running-apps