Last week I read Meta's write-up on how they built Forum with AI-native engineering. I read it twice. Then I sat down and asked a plain question about our own team: how far along are we, really?

What Meta wrote

A few ideas stood out to me.

Humans on the loop. Meta draws a line between human-in-the-loop and human-on-the-loop. In the first, the engineer drives every step and the AI helps inside it. In the second, the agent runs the whole iteration (plan, implement, build, test, correct, repeat) while the engineer sets the goal, watches the run, steps in when it drifts, and approves the result.

Verified means done. They set the bar at verification. Code that compiles is not done. A task is complete only once automated tests and visual checks have passed.

Fix it once. Their operating model has rules (a mistake the agent repeats more than twice gets encoded once, for everyone), skills (team conventions the agent can load), commands that chain skills and agents into workflows, and hooks, which are automatic triggers like running a linter after every agent turn.

And the headline result: Forum reached core feature parity with Facebook Groups in eight weeks.

Where we honestly are

We are at the first stage. I call it Assisted.

Our agents write a lot of code. We use Claude Code and others. They run on saved rules and skills, so a correction made once sticks. In that sense we already share Meta's "fix it once" instinct.

But a person steers every step, and a person reviews everything an agent produces. Every pull request. Every change to a product our customers depend on. That is human-in-the-loop, and right now it is the correct place for us to be.

We also run AI features in production, in FeatureOS and SupportWire. So this is not a thought experiment for us. It is how we work every day, and it is why we take quality so seriously.

The five stages

Here is how I think about the road from here. Each stage has a gate, which is what has to be true before we move on. We move on when a gate holds up, not when a date arrives.

Where we are

Stage 1 of 5. Assisted.

  1. 1 Assisted
  2. 2 Checked
  3. 3 Agents test the product
  4. 4 Delegated
  5. 5 AI-native

The short version:

  1. Assisted (today). Agents write code on saved rules and skills. People steer every step and review all output. Gate: automatic checks catch what our reviewers catch, run after run.
  2. Checked. Agent output passes automatic gates, like tests, evals and review bots, before a person looks. People review what passes. Gate: the checks hold up over time, and every change gets a preview build.
  3. Agents test the product. Every change gets its own sandbox or preview build, and agents click through the app like real users. Gate: agent-built, agent-tested changes pass consistently, and nothing slips past review.
  4. Delegated. Whole classes of work, like paper cuts, small fixes and upgrades, go to agents end to end. People spot-check samples. Gate: delegated work stays clean under spot-checks, and the checks earn default trust.
  5. AI-native. Agents are the default way work gets done. Engineers design the system and the checks.

Why we are careful

It would be easy to skip ahead. Hand a backlog to agents, merge what looks fine, and call it AI-native. I think that is how teams end up reviewing code that looks finished and is not.

So we have one rule: nothing moves up a stage until it has been tested, and a person stays accountable for quality at every stage.

In practice that means everything is human reviewed today. We only hand a kind of work to agents after it has been tested rigorously, and we hand it over one class at a time. If the checks start missing things, that class goes back to full review until we understand why.

The one rule

  1. 01 Full human review Every change, every line.
  2. 02 Tested, run after run Checks catch what reviewers catch.
  3. 03 Agents own it One class of work at a time.

Checks miss something? Back to 01.

Being careful is not the same as being slow. Every review we do now teaches us what the automatic checks need to catch later. The review is how we build the gate.

What we are working on next

The next step is Stage 2, Checked. That means building the gates that let a person trust an agent's work without reading every line first.

Concretely, that is three things:

  • Stronger automated tests around the parts of our products customers touch most.
  • Review bots and evals that run before a person ever opens the pull request.
  • Preview builds for each change, which also sets us up for Stage 3.

None of these are new ideas. Meta's post is a good reminder that they are the ideas that matter. Verification is the work.

Where we want to be

We want to be where Meta is. Engineers who own outcomes and design the system, and agents doing the routine implementation inside it, with checks strong enough that the quality bar holds by default.

And then we want to keep improving. AI-native is not a finish line. The tools will change, the models will change, and the checks will need to get better every time they do.

I also wrote down how we think about building AI a while ago. This roadmap is that thinking applied to our own engineering.

I will write again when we reach the next gate, and I will be honest about what it took.

We hold our client work to the same discipline. If you want to know how that works on your projects, that is what Skcript Applied Labs is for.