Eight weeks. That is how long it took a Meta team to rebuild the core features of Facebook Groups — forums, moderation tools, member management, the lot — from scratch. The engineers did not write the code. AI agents planned the work, built the changes, and ran the tests. The humans set the goals and signed off on the results.

It would be easy to read this as the end of the software job. It is actually a much more interesting story: the clearest public example yet of where the human work went. It did not disappear. It moved upstream — into goals, constraints, and the final yes.

And that migration is not staying inside engineering. The same pattern is arriving in every job that produces documents, analyses, and plans. Which is to say: yours.

What "Signed Off" Actually Meant

The tempting read is that the engineers went on holiday while agents worked. The reality was a different job, and a harder one to fake. Someone had to write the objective precisely enough that an agent could execute against it. Someone had to set the boundaries — which systems, which standards, which constraints are immovable. Someone had to review output at the seams where a confident error would cost a week. And someone had to own the result when it shipped.

Strip the job of its typing and what remains is the senior part: defining problems, weighing trade-offs, absorbing accountability. The agents absorbed the execution layer. The humans kept the judgement layer — and discovered that the judgement layer, done properly, is a full-time job.

The tooling curve behind this is moving fast. This week alone, agent platforms shipped upgrades built specifically for longer autonomous work — multi-hour tasks, cheaper runs, better recovery when agents go wrong. The distance between "AI assists the work" and "AI does the work, humans approve it" is collapsing. What Meta demonstrated at Facebook Groups scale, smaller teams will do at ordinary scale within a year.

The Pattern Is Already Leaving Engineering

Watch where the same shape appears outside code. A marketing team where agents draft the campaign variants and a human picks the angle. An ops function where agents reconcile the data and a human adjudicates the exceptions. A research workflow where agents compile the landscape and a human decides what it means. Each time: machine execution, human goals-and-approval.

Here is what it looks like in a job that has nothing to do with software. A regional manager runs a weekly performance report across twelve locations. The old version cost her Friday afternoon: pull exports, reconcile figures, format the deck, write the commentary. The delegated version works like the Meta build, scaled down to one person. She wrote the goal once — "weekly summary, twelve locations, flag any site more than five percent off target, commentary focused on causes not numbers." An agent pipeline pulls the exports, reconciles the figures, drafts the summary, and queues it for her Monday morning. Her Friday afternoon is now twenty minutes: check the flags the agent raised, correct the one commentary line that missed context, approve. The agent executes. She owns the outcome. That is the whole pattern — eight weeks of Meta engineering, compressed into a spreadsheet and an inbox. (The pipeline she uses — goal definition, agent execution, approval gates — is the practical curriculum of our AI Automation course.)

This reframes the career anxiety of the past two years. The question was never "will AI do my tasks" — for most knowledge work, large parts of it already can. The question is whether you are building the upstream skills the pattern rewards: specifying work precisely, setting boundaries deliberately, reviewing proportionally, and standing behind the outcome. Those are the skills that survived the Meta rebuild intact. In fact, they are the only skills the rebuild needed humans for.

There is a hard truth embedded here worth saying plainly. Delegating to agents looks effortless from the outside and is genuinely difficult to do well — the same way managing people looks easy until the team quietly produces the wrong thing for six weeks. Bad delegation to a machine produces fluent, confident, subtly wrong output at industrial scale. Good delegation is a discipline. The people fluent in it will run the teams.

The Three Ways Delegation to Machines Fails

Because the failure modes are the curriculum, they are worth naming. Under-specifying is the most common: the agent gets a goal vague enough that its confident interpretation is wrong, and the error ships before anyone checks — the machine did exactly what it was asked, which turns out to be the problem. Over-permissioning is the quiet one: the agent accumulates access beyond its task, so when it does err, the blast radius is everyone's problem instead of one workflow's. And review asymmetry is the expensive one: heavy scrutiny of low-stakes output while the irreversible decisions sail through unexamined — effort spent exactly backwards.

Each failure maps to a missing management habit, which is why the people good with teams get good with agents fast. Scope the work like you'd brief a capable stranger. Permission it like it could be wrong — because it will be, eventually. And put your attention on the output whose errors you cannot afford. The Meta engineers signing off weren't rubber-stamping; they were running exactly this discipline on a schedule.

Your Version of the Eight Weeks

You do not need Meta's infrastructure to start working this way. The entry-level version of "set goals, sign off on results" is available to anyone willing to structure it: pick one recurring piece of your week, define its done-state precisely, automate the execution, and keep yourself exactly where the Meta engineers stayed — at the approval gate, on the parts that are expensive to get wrong.

The sequence matters. Don't start with the biggest task — start with the most boring one: weekly, repetitive, low-stakes, easy to verify. Win there, and you have a working template plus the confidence to extend it. Fail there, and you've lost a week instead of a quarter. The managers who build reliable agent workflows all describe the same trajectory: one small pipeline that works, then a second, then a fleet.

Pick the first candidate properly and the rest follows. The right first automation is recurring (weekly or better — the setup cost pays back fast), verifiable (you can tell in thirty seconds whether the output is right, which makes review cheap while you're calibrating trust), and bounded (a bad run embarrasses you in a draft folder, not in a client's inbox). Reporting, reconciliations, digests, and first-draft production all qualify. What doesn't: anything client-facing on day one, anything touching money, anything where a confident error would outrun your review. Those come later — with permissions earned, not assumed.

Most people never get there, not because it is technically hard but because nobody teaches the workflow. Using AI casually — a chat window, a quick answer — builds none of it. Operating AI as an executor, with pipelines, triggers, boundaries and review points, is a different skill entirely. The first makes you a consumer of the shift. The second makes you the person running it.

There's a career-market signal buried in the Meta story too. The engineers who ran that rebuild just became the most hireable engineers in the industry — not because they can code faster than agents, but because they've demonstrably operated the pattern everyone else is about to need. "Ran an agent-executed build; humans held goals and sign-off" is becoming the most valuable line on a technical CV. The non-technical equivalent — "designed and ran AI-executed workflows across my function" — is just as scarce, and just as legible.

The fleet part is where it gets interesting, because it changes the unit of your output. One pipeline saves an hour a week. Five pipelines — each with a defined goal, scoped permissions, and a review point — is a small automated team running under your sign-off, and your week starts to look like the Meta engineers': less execution, more direction and approval. That is not a hypothetical org chart. It's a personal productivity curve, and it's available to anyone willing to build it deliberately.

Your eight weeks won't rebuild Facebook Groups. They'll do something more useful: reclaim a Friday afternoon. Pick the most boring recurring task you own — the report, the reconciliation, the digest — define its done-state in writing, and build the first pipeline. When it runs clean for the third consecutive week, you'll understand the Meta story differently: not as a curiosity about big tech, but as a preview of your own job's next chapter — one you get to write ahead of schedule, on your own terms.

That operating skill is the subject of our 7-day email course AI Automation — from identifying which of your work should be delegated to machines, through building multi-step automated pipelines, to the review discipline that keeps delegated work trustworthy. It pairs with our earlier piece on why AI agents need a manager: Meta just spent eight weeks showing what that management looks like in practice. Ready to supervise rather than just operate? Our Supervising AI Agents at Work course is the next layer up.