Ugrás a fő tartalomhoz

AI-Native Engineering for Forward Deployed Engineers

Basic

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.

TL;DR
  • 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, /clear between 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 agentWith a well-set-up agent
Days reading an unfamiliar codebase before the first changeAgent explores in a separate context and returns a summary (see Context Engineering)
Client conventions live in people's headsConventions 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, repeatThe agent runs the loop and you review a verified diff (see The Agent-Ready Toolchain)
Risky commands depend on your attentionPermissions 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​

LeverQuestion it answersWhat you controlHome pages
ContextDoes the agent know what it needs, and only that?Session scope, AGENTS.md, memory, plans, skills, MCP serversContext Engineering, AGENTS.md, Memory, Skills, MCP
Feedback loopCan the agent tell if it is right?Tests, linters, type checks, build, fast deterministic toolsToolchain, Execution Plans
GuardrailsWhat happens when the agent is wrong or manipulated?Permissions, hooks, pre-commit, CI, least-privilege MCPHooks 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.

#PageYou will learnTime
1This pageThe three levers, exam map, habits, maturity ladder45 min
2Context EngineeringWhy long sessions get worse, and how to keep sessions focused45 min
3AGENTS.md, CLAUDE.md, and RulesWhat goes into project instructions and what stays out45 min
4Scratchpads, Memory, and Markdown Knowledge BasesHow to keep knowledge across sessions45 min
5Execution PlansHow to go from epic to verified change with plan files60 min
6Skills and Skill CreationHow to package a repeatable procedure as a skill60 min
7MCP ServersWhen to add an MCP server, which ones, and how many45 min
8Hooks, Pre-commit, and Quality GatesHow to enforce what must always happen60 min
9The Agent-Ready ToolchainWhy fast, deterministic tools make agents better45 min
10Agent HarnessesHow to choose a harness and stay harness-agnostic30 min
11Lab: Make a Repository Agent-ReadyApply everything to one real repo90 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)​

ItemValue
Format60 items, multiple choice and multiple response
Scenarios4 scenarios drawn at random from a pool of 6
Duration120 minutes, proctored
ScoringScaled 100 to 1000, passing score 720
Price$125 USD
DeliveryPearson VUE (moved there on 2026-06-30)
Validity12 months from the date earned
Retakes14 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​

Check the official wording

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.

#DomainWeightPages in this sectionExisting pages
1Agentic Architecture & Orchestration27%Execution Plans (subagents, parallel work), Hooks and Quality Gates (human-in-the-loop), Agent HarnessesAgentic AI Platforms covers agent architecture and workflow patterns
2Tool Design & MCP Integration18%MCP Servers, SkillsAgentic AI Platforms covers MCP in client systems
3Claude Code Configuration & Workflows20%AGENTS.md, CLAUDE.md, and Rules, Skills, Execution Plans (plan mode), Hooks and Quality Gates, Agent Harnessesnone
4Prompt Engineering & Structured Output20%Partial: Execution Plans (writing precise task specs), Context EngineeringAgentic AI Platforms for schema-checked outputs in agents; use Anthropic's API docs for structured output
5Context Management & Reliability15%Context Engineering, Memory and Knowledge, Hooks and Quality GatesAgentic 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​

#HabitLeverDetails
1One task per session; /clear between unrelated taskscontextContext Engineering
2After two failed corrections, /clear and write a better promptcontextContext Engineering
3Send research to a subagent so it does not fill your main contextcontextContext Engineering
4Check what loads before you type (/context)contextContext Engineering
5Keep AGENTS.md short; test each line: would removing it cause mistakes?contextAGENTS.md, CLAUDE.md, and Rules
6AGENTS.md is the source of truth; CLAUDE.md imports itcontextAgent Harnesses
7Scope rules to paths so they load only when neededcontextAGENTS.md, CLAUDE.md, and Rules
8Keep a scratchpad for the current task and notes for the next sessioncontextMemory and Knowledge
9Explore, then plan, then implement, then commitcontext + feedbackExecution Plans
10Write one plan file per slice of an epic, with a verification step eachfeedbackExecution Plans
11Run parallel work in separate git worktreesfeedbackExecution Plans
12Give the agent a way to verify: tests, linter, build, screenshotfeedbackToolchain
13Pin tool versions with mise so the agent and CI run the same toolsfeedbackToolchain
14Turn a procedure you paste twice into a skillcontextSkills
15Add an MCP server only for a clear need; keep the list shortcontextMCP Servers
16Pin MCP server versions and grant least privilegeguardrailsMCP Servers
17Use hooks for what must always happen; rules are advisoryguardrailsHooks and Quality Gates
18Run format and lint after every edit, and again in pre-commit and CIguardrails + feedbackHooks and Quality Gates
19Ask a fresh-context reviewer subagent to check the work before you dofeedbackExecution Plans
20Check the client's approved providers and data rules before choosing a harnessguardrailsAgent Harnesses

The maturity ladder​

LevelNameWhat it looks likeAdd this to move up
0Chat in a browserYou paste code into a chat window and copy answers backInstall a harness in the repo (see Agent Harnesses); let it read files and run commands
1Agent in the repoThe agent edits files and runs commands, with no project instructionsA short AGENTS.md with build, test, and style commands (AGENTS.md); the /clear habit (Context Engineering)
2Agent with context and a feedback loopAGENTS.md, scoped rules, and a one-command test, lint, and build; the agent verifies its own workPlan files for non-trivial work (Execution Plans); skills and a few MCP servers (Skills, MCP)
3Planned work with guardrailsPlan mode before code, execution plans per slice, permissions set, hooks run format and lintHooks, pre-commit, and CI gates the agent cannot skip (Hooks and Quality Gates); pinned toolchain (Toolchain)
4Parallel agents with enforced gatesSeveral agents work in worktrees on separate plans; gates block bad changes; a reviewer agent checks resultsKeep 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

  1. 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.
  2. Run /context (Claude Code) or the equivalent and note what loads before you type anything. Is any of it unneeded?
  3. Check for the files: AGENTS.md, .claude/rules/, .claude/skills/, .mcp.json, .claude/settings.json, a pre-commit config, a mise.toml.
  4. 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?
  5. Place the repo on the ladder using the table above. Write down the single next row item you will add this week.
  6. 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​