XNews

AI Engineering Practices: FDE, Long-Running Agents, and Cursor Development Processes

AI Engineering Practices: FDE, Long-Running Agents, and Cursor Development Processes

An overview of engineering AI development practices and processes provided by OpenAI, Anthropic, and Cursor.

Key insights

Definition and Goals of FDE

Forward Deployed Engineering (FDE) is defined as deploying top core technology engineers directly on-site with clients, collaborating day and night with business experts to deeply understand pain points and rapidly iterate usable solutions, ultimately refining reusable products that benefit more clients. The former CTO of Palantir likened it to 'eating the pain and pulling out the product.'

Four Core Principles of OpenAI FDE

OpenAI emphasizes four key points in its FDE practices: focusing only on high-risk, high-value problems (such as Morgan Stanley applying GPT-4 in wealth management); prioritizing trust-building and continuous iteration over demonstrations (the Morgan Stanley pilot took six months); developing with a strict eval-driven approach, where any code written by large models must pass eval verification; and making clear trade-offs between deterministic and probabilistic tasks, ensuring critical decisions are guaranteed by deterministic code.

Commercial Decisions and Discipline in FDE

FDE can serve as a short-term revenue-generating service or a long-term path to productization. Colin Jarvis points out two distinctly different approaches: treating FDE as a consulting service for short-term monetization, or viewing FDE as a means of productization from zero to one. True discipline lies in saying no to non-strategic clients when funds are scarce and temptations are high. The ultimate goal of FDE is to leave with a product, with a potential reuse rate of 20% for the first client, rising to 50% for the second or third as productization begins.

Evolution Path of Agent SDK from Custom to General Use

OpenAI's Agent SDK and Agent Kit evolved from custom projects for clients: initially refined in a custom project for Klarna, then iterated with clients like T-Mobile, ultimately forming a general agent framework that reflects the path of customizing before productizing in FDE.

Key Failure Modes Faced by Long-Running Agents

Anthropic's engineering blog highlights common failure modes for long-running agents in complex tasks spanning hours or days: context window limitations causing each session to feel like starting from scratch, premature completion declarations, difficulties in state recovery, and the absence of end-to-end testing leading to hidden bugs. Experiments (such as building over 200 functional web clones) reveal these issues and quantify failure modes.

Anthropic's Dual-Agent Framework and Engineering Practices

Anthropic recommends introducing a 'framework' and using dual agents: the Initializer Agent sets up the environment and generates feature_list.json, claude-progress.txt, init.sh, and makes the first Git commit during the initial session; the Coding Agent implements each item in the JSON feature list, runs init.sh, executes tests, and updates the pass status in subsequent sessions, marking completion only after passing tests. It is also suggested to use a JSON feature list, prevent premature completion, integrate end-to-end automated testing (such as validation based on Puppeteer), and enforce strict prompting strategies.

Cursor's Practical Development Cycle and Model Mixing Strategy

Eric describes the Cursor development workflow as cyclical: starting with a high-level model (Claude Opus 4.5 or GPT-5.1-Codex) for preliminary understanding, switching to Cursor's planning mode to generate editable Markdown plans, iterating through interaction, then using Composer-1 to generate code and conduct light reviews, followed by developers running tests for validation and making adjustments as needed, with the option to revert to high-level models for deep audits and refactoring when necessary. The key principles are 'always review the code' and optimally mix models based on tool suitability.

Specific Steps and Tools in the Cursor Process

The Cursor process consists of seven specific steps: preliminary understanding (high-level model), switching to planning mode to generate plans, interactive iteration, Composer-1 generation and initial review, manual test execution, subsequent adjustment cycles, and deep review and refactoring when necessary. The process emphasizes layered model usage, manual validation, and the advantages of visual review, noting that it is suitable for feature development, bug fixing, and full lifecycle development, assisted by tools like Bugbot.

Source posts