What Is a Forward Deployed Engineer, and Who Reviews the Code the AI Writes?
One embedded engineer owns the work, and AI writes much of the code. This guide explains the role and how to review that code before it ships.

A forward deployed engineer (FDE) is a software engineer who works inside a customer’s team and owns a product or workstream end to end, from requirements to release. The role started at Palantir and spread to AI labs and AI product companies. Today many FDEs build with AI at every step, which raises a question the usual definitions skip: when one engineer ships code an AI model helped write, who reviews it for security?
The short answer is that the forward deployed engineer owns the review, but should never be its only line of defense. AI-generated code still fails security tests often enough to matter. Veracode’s October 2026 benchmark found vulnerabilities in 38% of AI code generation tasks. Meanwhile, the Linux Foundation’s 2026 practitioner survey found that most teams already ship faster than their security review can keep up. A forward deployed model works safely when four things are true: the engineer reviews and approves every AI output, AI security tools add a second automated pass, the customer’s decision-maker signs off on staging, and an independent test checks the work at regular intervals.
What is a forward deployed engineer?
A forward deployed engineer is a software engineer embedded with one customer who builds whatever that customer’s workflow needs and takes responsibility for the outcome. The role was created at Palantir in the early 2010s, where these engineers were called “Deltas,” and it has since been adopted by AI labs and software companies that need their product to work inside each customer’s systems.
Day to day, a forward deployed engineer gathers requirements from the people who do the work, builds in the customer’s own stack and repositories, writes the tests, releases, and reports progress to a decision-maker on the customer’s side. The same engineer carries the work from the first conversation to the release.
The clearest description of the difference comes from Palantir itself, as quoted in The Pragmatic Engineer’s deep dive on forward deployed engineers: a product developer’s focus is “one capability, many customers,” while a forward deployed engineer’s focus is “one customer, many capabilities.” A product engineer optimizes a feature for everyone. A forward deployed engineer goes deep on one organization: its data, its integrations, its users and its constraints.
That depth is why the role grew so fast with AI. A language model or an agent can look impressive in a demo and still fail in production, because production means messy data, legacy integrations, access rules and people whose jobs change. Someone has to sit inside that environment and make the software work there. OpenAI now runs its own FDE function, and the term is used across AI labs for engineers who take models into customer workflows and bring what they learn back to the product team.
How a forward deployed engineer differs from a software engineer
The titles overlap, so the useful test is who owns what. A forward deployed engineer writes production code and answers for the result. A product software engineer builds for many customers at once, and the other adjacent roles either sell, advise or work a backlog someone else directs.
| Role | Main output | Who they serve | What they own |
|---|---|---|---|
| Forward deployed engineer | Production software in the customer’s systems | One customer or workstream | Delivery, from requirements to release |
| Product software engineer | Reusable product features | Many customers | A feature or service in the product |
| Solutions engineer | Demos, proofs of concept, technical answers | Prospects in a sales cycle | The technical side of the deal |
| Consultant | Recommendations, sometimes implementation | One client per engagement | The remit agreed in the engagement |
| Staff augmentation engineer | Contributions to a backlog | A client lead who directs the work | Tasks assigned by the client’s lead |
The last row matters for buyers. With staff augmentation, your own lead directs the engineers and owns the outcome. With a forward deployed engineer, ownership of the workstream moves to the engineer, and that includes ownership of what ships. That is where security review comes in.
Why the FDE model now runs on AI
AI tools have changed how much one engineer can own. Owning a workstream has usually meant relying on other people for design, testing and project management. With AI across planning, code, tests and documentation, one senior engineer can now cover several roles, as long as they review every output before it ships.
We have seen this on our own work. On a pet adoption and rehoming marketplace unicrew designed and built, the build phase was delivered by five people: two engineers, a QA engineer, a designer and a project manager. That shape is sized for building the foundations in parallel, and steady delivery afterwards is a different job. Since then, one engineer from that team, working directly with the founder and using Claude, has covered all five roles for more than six months, with no roles backfilled. The engineer reviews what Claude produces and decides what ships, and the founder verifies every feature on staging before release. The case study on how one engineer keeps the marketplace shipping describes how each role is covered.
Covering several roles also means taking on the checks those roles used to provide. A designer, a QA engineer and a project manager each look at a change from their own angle. When one engineer covers those roles with AI, the same checks run through one person and the tools that person chooses, so the process has to make sure AI output is never treated as finished work.
So the question for a buyer considering an AI-native forward deployed engineer is not whether AI writes good code. It is whether the engagement has a review process that does not depend on the AI being right. Our guide to building AI-native development teams covers how roles and code review change once AI sits inside a team. The rest of this post focuses on the security side of that review.
How secure is AI-written code in 2026?
AI-written code is getting more secure, but it is still not safe to ship without review. Veracode’s October 2026 GenAI Code Security Report found that the average security pass rate across the 18 models it tested rose from 56% to 62%, which still leaves 38% of code generation tasks producing vulnerable code. The gains were also uneven: log injection, which Veracode says requires data-flow reasoning across multiple functions, remained flat at 13%.
Veracode asks models to complete coding tasks and scans the output for known weaknesses. Until the October 2026 update, the results had barely moved since the series began in July 2025. Meanwhile, Veracode’s July 2026 report noted that AI now authors roughly half of all committed code in organizations that have adopted AI coding tools. The October gain is real, but the details matter more than the average.
- Most of the gain came from cross-site scripting (XSS). Veracode notes that XSS is the easiest vulnerability to fix through pattern recognition, which is exactly how models improve.
- Log injection did not move. Veracode says it requires data-flow reasoning across multiple functions, where models continue to stall. A reviewer finds this kind of flaw by following data through the system rather than by reading one diff.
- The weakest models did not improve. The bottom of the leaderboard still sat at 44 to 50%, so the choice of model is itself a security decision.
- Language matters. The Java pass rate was 31%, against 64% for Python.
The other half of the picture is how teams handle that code. The Linux Foundation’s State of AI Impact on Software Security and Cybersecurity 2026, supported by OpenSSF and published in November 2026, surveyed practitioners on exactly this.
- 58% of teams ship code faster than security review can keep up. The report warns that this can leave a backlog of vulnerabilities that are not addressed in time.
- Only 57% of AI security policies mandate human review of AI-generated code. In other words, mandatory human review is missing from the rest, and the report says it should be a feature of more policies.
- 60% say AI coding tools increase the number of external dependencies in their codebases. The report also found that teams review transitive dependencies only about half the time, so every package an AI suggests widens the attack surface.
- 82% warn that overreliance on AI weakens developers’ security skills. This is the risk a forward deployed model has to design against, because one engineer’s judgment is the main control.
Put together, the 2026 data says two things. AI code is improving, mostly on the easy flaws. And the bottleneck is now review capacity, not code generation. Our post on generative AI security risks covers the vulnerabilities AI features add to a product, and our guide to secure application development covers scanning, dependencies and secrets across the pipeline. The rest of this post covers the review side: who reads the code, and what tools help them.
Who owns security review when one engineer owns the workstream?
In a forward deployed engagement, the engineer owns security review for their workstream: they review every AI-generated change, decide what ships and answer for it. Owning the review should not make the engineer the only check, so a sound engagement adds three more: an automated security pass that the engineer runs, acceptance of each feature by the customer’s decision-maker, and periodic testing by someone who did not write the code. The automated pass gives every change a second look, and the last two add checks from people outside the work.
This mirrors a principle security teams have used for decades: separation of duties. The person who writes a change should not be the only person who approves it. In a traditional team, that separation comes from people: a reviewer, a QA engineer, a security lead. In a forward deployed model, one engineer writes and approves most changes, so the separation has to be designed into the process instead: the customer accepts the behavior, and someone outside the workstream tests the system.
Here is how responsibility should divide.
| Responsibility | Who holds it | Why it sits there |
|---|---|---|
| Reviewing and approving every AI output | The forward deployed engineer | They hold the full context of the system and the change |
| A second automated security pass | AI security tools and scanners, run by the engineer | They read every change without fatigue and catch known patterns |
| Accepting features before release | The customer’s decision-maker, on staging | The person who owns the business outcome confirms the behavior |
| Setting the rules for AI tools and data | The customer, through their AI and data policy | The customer owns the risk and the data |
| Testing the system as an attacker would | An independent tester, outside the workstream | Someone who did not build it looks for what the builder missed |
Two of those rows are often skipped, and both matter.
The first is the customer’s decision-maker. An acceptance check on staging is not a code review, but it catches a different class of problem: features that do something the business never intended, including exposing data to the wrong users.
The second is the policy row. A forward deployed engineer works inside the customer’s systems, so the customer’s rules decide which AI tools may touch their code and whether any customer data can be used with them. On unicrew’s engagements, we use only tools the client’s policy approves for their code, and the engineer’s access is limited to the work. Settling this before the first commit is far easier than unwinding it after an incident.
What AI security review tools catch, and what they leave to people
AI security review tools now find real vulnerabilities at scale. Anthropic’s Claude Security and OpenAI’s Codex Security both build a threat model of your codebase and rate each finding by its real-world impact. Neither replaces the people who decide what to fix, and that work, not finding flaws, is now the hard part.
Claude Security: continuous scanning with a threat model
Anthropic launched Claude Security in public beta in April 2026, and in October moved it from on-demand scans to continuous monitoring. According to Anthropic’s announcement, it now keeps up with connected repositories as the code changes and tracks findings until they are fixed. It also generates a threat model from the code that the team can review and edit, and gives each finding a severity rating and an explanation of how an attacker could reach the vulnerable code. Anthropic says thousands of organizations have used it to find more than a million vulnerabilities since the beta began.
Codex Security: validation before a finding reaches you
OpenAI launched Codex Security in research preview in March 2026, building on its earlier Aardvark agent. OpenAI’s announcement describes three stages. First, the tool builds an editable, project-specific threat model. Next, it searches for vulnerabilities and, where possible, pressure-tests them in sandboxed validation environments. Finally, it proposes patches that fit the system’s intended behavior. OpenAI frames the problem the same way the Linux Foundation data does: agents are accelerating development, making security review an increasingly critical bottleneck.
The bottleneck has moved from finding to fixing
The clearest evidence of that shift comes from Anthropic’s Project Glasswing, a restricted program that gave partner organizations early access to the Claude Mythos Preview model. In its initial update in May 2026, Anthropic reported that Mythos Preview had flagged more than 6,000 vulnerabilities it estimated as high or critical severity across more than 1,000 open-source projects, and that 90.6% of the high- or critical-rated findings checked so far were real. Anthropic wrote that the bottleneck is now the human capacity to triage, report, and design and deploy patches, and noted that some maintainers had asked it to slow its disclosures.
For a company running a single forward deployed workstream, this has a practical meaning. A single scan can surface more findings than one engineer can fix in weeks, so triage becomes a core part of the engineer’s security work.
What the tools leave to people
Even good tools leave four jobs to the engineer and the business.
- Business logic. A scanner can trace data flows, but it cannot know that a refund should never exceed the original payment, or that one tenant’s admin must never see another tenant’s users. Those rules live in requirements, not in code patterns.
- Deployment context. Whether a finding is reachable depends on how the system is deployed, which is why both vendors let teams edit the threat model. Someone has to supply that context and keep it current.
- Choosing the fix. A proposed patch can close the hole and break a workflow. The engineer who owns the workstream judges the trade-off and decides what to ship first.
- Permission to scan. A forward deployed engineer works in the customer’s repositories, so the customer has to approve a scanning tool, and what it may send outside their environment, before it touches their code.
The coding agent is part of the attack surface
The AI tools a forward deployed engineer uses need securing too, not only the code they help write. Coding agents run commands, read repositories and hold credentials on the engineer’s machine. In September 2026, researchers at Accomplish AI showed that opening a malicious repository in OpenAI’s Codex coding agent and asking it a question could let the repository’s author run commands on the developer’s machine.
The researchers disclosed two ways to escape the agent’s sandbox. As Accomplish’s write-up explains, one flaw let a single extra line in a patch give the agent’s patch tool write access to the whole disk, with no approval prompt. The other let whoever wrote a cloned repository run commands outside the sandbox, even in read-only mode. OpenAI fixed both issues within eight days of the August report. The lesson is wider than one product: a repository the agent reads is input, and input can be hostile.
For a forward deployed engagement, this turns into a short list of controls.
- Approved tools only. The engineer uses the AI tools the customer’s policy approves for that codebase, at current versions, and nothing else.
- No real user data in AI tools. Where the work allows it, AI tools see code, schemas and synthetic or anonymized data, never production records.
- Untrusted code stays isolated. Repositories from outside the customer’s organization are opened in a sandbox before any agent is allowed to work on them.
- Least-privilege credentials. The agent’s environment holds only the credentials the task needs, and production secrets stay out of it.
None of this is exotic. It is the same discipline a security team applies to any third-party tool with access to source code, applied to a tool that also writes the code.
A security review routine for an FDE workstream
A forward deployed engineer can ship AI-assisted code safely with a seven-step routine that runs on every change and does not depend on the AI being right: set the data boundary, threat-model the feature, generate with tests, run an AI security pass, review and approve by hand, check dependencies, and get sign-off on staging. An independent penetration test at regular intervals sits on top.
- Set the data boundary before the first commit. Agree with the customer which AI tools may be used on their code and which data those tools may see. A safe default is that AI tools work on code, documentation and anonymized or synthetic data, never on real user records.
- Threat-model each feature before building it. Write down what the feature trusts, what it exposes and what an attacker would try. For messaging, that means asking who can read a thread. For payments, it means asking whether an amount can be changed in transit. This takes minutes, and it gives both the engineer and the AI tools the context they need.
- Generate the code with its tests. Tests are written in the same pass as the feature and run in CI on every change. Security-relevant behavior gets its own tests: authorization checks, input validation, and rejection of malformed requests.
- Run an AI security pass on every feature. Before a feature ships, an AI security review works through how an attacker would approach it and how the code holds up, alongside any scanners the customer already runs. Tools like Claude Security or Codex Security can add continuous scanning across the repository.
- Review and approve every change by hand. The engineer reads every AI-generated change and every proposed fix, and decides what ships. Reasoning attached to a fix makes this faster, but the decision stays with a person.
- Check what the change pulled in. New packages, and the dependencies they bring with them, get the same scrutiny as the code. This is where the Linux Foundation data shows teams falling short, so it needs a deliberate step.
- Get sign-off on staging. The customer’s decision-maker verifies each feature on staging before release. This catches behavior the business never intended, which code review alone can miss.
The penetration test runs on a schedule rather than per change. Run by people outside the workstream, it looks at the system the way an attacker would. Our penetration testing services cover this for clients whose risk or compliance obligations call for it. Where QA needs its own owner, our ISTQB-certified QA engineers run independent software testing as a separate engagement. Our post on whether AI can hack your software explains why that outside view matters more now that attackers use the same AI tools.
How we run security review on our FDE engagements
On unicrew’s forward deployed engagements, the engineer reviews everything AI produces before it ships and works inside the client’s AI and data policy, with only the access the work needs, and a decision-maker on the client side signs off releases. Two engagements show how that works when security and personal data are at stake.
A marketplace with security-reviewed messaging
On the pet adoption and rehoming marketplace, messaging is where the product earns trust. Users coordinate adoptions through in-app messaging without sharing personal contact details upfront. The engineer hardened the messaging layer and ran a security review with Claude Code on every feature before it shipped, working through what an attacker would try and how the code holds up. The same engineer extended and hardened the platform’s automatic listing validation, which screens photos and text for prohibited content. The aim is to block prohibited content before publication rather than remove it after a complaint, and user reports remain a second line of review.
Claude works on the code, the design and the documentation, but it never sees real user data. The in-chat scam warning, for example, runs inside the marketplace’s own platform: Claude helped build it and never sees users’ messages or any other real user data.
A live integration migrated using anonymized records
On a waiver and document management platform for the fitness industry, which unicrew has developed since 2014, unicrew’s forward deployed engineer led the migration of a live CRM integration to a new API version, with other unicrew engineers contributing. The platform handles personal data, so privacy shaped the method from the start. During development, every CRM call ran against both API versions, and the records kept for comparison were anonymized before analysis. Claude Code analyzed those anonymized records to find differences between the versions, including ones that produced no error at all. The engineers, led by the forward deployed engineer, reviewed and approved every fix before release.
The migration was estimated at 260 hours and delivered in about 80. A request that failed on the new API was automatically retried on the legacy one, so user operations could complete while the integration was live. The case study on the Claude-assisted CRM migration describes the method step by step.
What every engagement includes
Every unicrew forward deployed engagement has the same foundations, whatever the client’s stack.
- Access comes after the paperwork. Contracts and NDAs are signed before access.
- The client owns the work. Code, documentation and the decision log live in the client’s repositories and belong to the client from the first day.
- Someone else knows the account. A second unicrew engineer knows each account well enough to cover absences.
- AI-assisted changes get no shortcut. They go through the same review and tests as any other change.
Of the four conditions at the start of this guide, two are part of every unicrew forward deployed engagement: the engineer reviews and approves every AI output, and a decision-maker on your side signs off releases. The other two depend on your policy and your risk: which AI security tools may scan your code, and whether independent testing comes from your own security team or from our penetration testing and QA services as separate engagements.
If you run a software company, the engineer can also work with your customers where they are part of the work. Our forward deployed engineering service covers how engagements are scoped and staffed, and our page for SaaS companies covers how we work with product businesses. Most engagements start within two to four weeks, and there is no minimum engagement period.
If your next workstream will be built with AI and you need to show who reviews it, talk to us about how we would run that review in your environment.
Where an FDE fits security-sensitive work
A single forward deployed engineer fits security-sensitive work when the foundations exist, someone on the customer side can make release decisions, and the security requirements can be met by one engineer’s review plus independent testing. Three situations call for a different setup.
- Greenfield builds with no foundations. A new product with no architecture or design system needs design, engineering, QA and DevOps working in parallel. One engineer with AI is fastest once the foundations exist, not before, so a dedicated software development team is the better start.
- No decision-maker on your side. The model depends on someone who can rule on priorities and sign off releases quickly. Without that person, the staging check disappears, and so does one of the independent controls. If nobody can take that role yet, a managed development team, which unicrew staffs, runs and stays accountable for, carries more of the delivery.
- Regulated or high-assurance systems. If your compliance obligations require formal separation between development and security testing, or a dedicated security function, a forward deployed engineer can own the delivery, but security needs its own owner alongside them. Our cybersecurity consulting and penetration testing services can work alongside the engineer.
If another team built the system, start with a written assessment of what you already run. A forward deployed engineer who did not build the product needs that context before they can review changes to it safely, and our technology advisory and technical due diligence service produces that assessment.
Key takeaways
- A forward deployed engineer owns one customer’s workstream end to end. The role came from Palantir and spread to AI labs because AI products only create value once someone makes them work inside each customer’s systems.
- AI lets one engineer cover several roles, which concentrates review on that engineer. The engagement needs a review process that does not depend on the AI being right.
- AI code is improving, but not enough to skip review. Veracode’s October 2026 benchmark still found vulnerabilities in 38% of AI code generation tasks, with log injection, which needs data-flow reasoning across multiple functions, still flat at 13%.
- Review capacity, not code generation, is the 2026 bottleneck. The Linux Foundation found 58% of teams ship faster than security review can keep up, and only 57% of AI security policies mandate human review.
- AI security tools help, and people still decide. Claude Security and Codex Security build threat models and rank findings, but triage, business logic and the final call stay with the engineer and the business.
- Secure the agent as well as the code. Approved tools only, no real user data, isolated untrusted repositories and least-privilege credentials.
- Design separation of duties into the process. Engineer review, an automated security pass, decision-maker sign-off on staging and periodic independent testing together do what a larger team used to do by headcount.
Frequently asked questions
A forward deployed engineer works inside the customer's team and owns one product or workstream from requirements to release. They gather requirements from the people who do the work, build in the customer's stack and repositories, write tests, release, and report progress to a decision-maker. An AI-native FDE also uses AI for planning, code, tests and documentation, and reviews every output before it ships. Our forward deployed engineering page describes how we run it.
In practice, yes. Owning a workstream alone means making product, engineering and security decisions without a team around you to catch mistakes. When AI writes much of the code, that judgment matters more, because the engineer is the one who approves what ships. Every forward deployed engineer unicrew assigns is a senior engineer from its own in-house team.
In AI, a forward deployed engineer takes models, agents and AI features into a customer's real workflows and systems: search, document processing, assistants and automation. AI labs adopted the role because a model that works in a demo still has to be integrated, evaluated and secured inside each customer's environment. The same title is also used for engineers who build with AI tools across the whole job, from requirements to release.
A product software engineer builds one capability that many customers use. A forward deployed engineer works the other way: one customer, many capabilities. The FDE sits with the customer, learns their workflow and builds whatever that workflow needs, from integrations to internal tools, then carries what they learn back to the product. FDEs also spend far more time with users and decision-makers than most product engineers do.
Yes, but only the access the work needs. A forward deployed engineer works in your repositories, tools and environments, so access should be scoped to the workstream, granted under your policies and removable at any time. Contracts and NDAs come before access, AI tools are limited to those your policy approves, and real customer data should stay out of AI tools wherever the work allows. unicrew holds ISO 27001:2022 certification.



