Meta Built Its Forum App With an AI Agent Running the Engineering Loop

From human-in-the-loop to human-on-the-loop

According to Meta, Forum is a standalone Groups app that a small team built from scratch. It was also a testbed for a different way of working. The team says its measure of success was not code volume but verified, production-ready outcomes: changes that build, pass tests and survive review.

In the human-in-the-loop model, the engineer drives every step and the AI assists inside it, for example by autocompleting a function or suggesting a fix. In the human-on-the-loop model, the agent runs the iteration itself: plan, implement, build, test, correct, repeat. The engineer sets the goal, watches the run, steps in when it drifts and approves the result.

Meta describes this as a target, not a finished state. Some stages run autonomously today, while others still keep an engineer in each iteration. Every shipped outcome still carries an engineer's sign-off, and the team says it worked to make that sign-off fast by attaching build results, test outcomes and recorded verification sessions to the change.

Verification as the bar, and the machinery around it

Meta argues that pointing AI at the coding step alone changes little. Its results compounded as the approach extended to planning, building, testing and verification. Without verification, the team says, AI-generated code produces plausible output that nobody has confirmed works, which shifts the burden to reviewing code that looks finished and is not. A task counts as complete only once automated tests and visual checks have passed.

The team lists four capabilities that let the loop run safely:

• Planning as technical specification: ambiguity an engineer might resolve by intuition causes agent failure, so the team invested in upstream decomposition and machine-readable context.
• Automated verification inside the loop: build status, unit tests and UI spec matching feed pass/fail signals to the agent, producing ready-to-review pull requests with pre-populated test plans and recorded verification sessions.
• Simulated user testing with agents: navigation agents use the live app like a person, read the screen and report regressions.
• Agentic production operations: after launch, agents use user feedback to investigate possible regressions and pass their analysis to engineers, who decide what to do next.

The operating model has five components: rules (permanent project instructions, encoded once when the agent repeats a mistake more than twice), skills (team conventions as loadable steps), agents (automating checks that used to be manual), commands (chains of skills and agents into workflows) and hooks (automated triggers such as running a linter after every agent turn).

Changing the environment, not the prompts

Meta says its biggest gains came from changing code and tooling rather than prompts. It kept Forum's codebase straightforward and modularized key parts of the architecture so agents could plug in easily. Where that was not possible, it rebuilt from scratch, trading reuse for agentic throughput, which the team says paid off in development speed.

The main failure mode was the agent losing track of where it was in the app, such as editing the home feed when asked to change the group home screen. Instead of describing the app, the team gave the agent tools to read the live view hierarchy from the simulator, list on-screen elements and look up the path to a target view before acting. According to Meta, misdirected edits dropped sharply.

For prototyping, the team built a separate build flavor: a sandbox app sharing the same codebase, frameworks and design system as production, with prototype code compiled out of the production build through a plugin/socket architecture. Meta says designers and cross-functional partners could prototype with AI tools without an engineer for each change, sandbox work could be ported to production without a rebuild, and prototype code could not crash the production app because it did not exist in that build.

Stress testing and what it means

The team also used the agent as a tester. It set up repeatable stress scenarios that mimic user behavior, including aggressive scrolling, random group browsing, rapid navigation and repeated media loading, and ran them routinely across builds. The runs yield signals such as crashes, memory growth, page faults and UI regressions, which the agent can triage and trace to a triggering sequence.

One run surfaced a memory issue. According to Meta, the agent isolated a repro, proposed a fix and verified it during development, before the app reached users. The fix materially reduced on-device memory growth and page faults across repeated stress sessions. Engineers still made the architectural decisions.

For engineering teams, the account points to where Meta says the effort lies: trustworthy verifiers, legible code and tools that let agents check state directly. The post says how much can be safely handed to the loop depends on how far the verifiers can be trusted. The source text available here ends partway through a section on applying the approach to Forum's feed.