Ferneri

How software gets built in 2027

Agents that plan, build, review and integrate, with people directing. What became standard practice, and how we run it.

A traffic signal at night, lit green on all three lenses: a pair of vertical bars above, a full green disc below it, and a green arrow pointing right on the arm beside them, the housing and the mast behind them in silhouette against a dark grey sky.

The unit of work in software has changed. It is the agent: a model running in a loop with tools, taking a piece of the job and checking its own result while a person directs the run. Google's chief executive said in April 2026 that 75 percent of the company's new code is AI-generated, against 25 percent two years earlier, and described the workflow as engineers supervising autonomous digital teams. The question that follows is the interesting one. How does a group of agents run at once and still produce something you would merge? Those answers are public now, settled into open standards and shipped as products, and this page is how we run them, with the published work behind each part.

An agent is a loop

An agent is a model called in a loop with tools. It reads a file, runs a command, reads what came back, and decides the next call. That is the whole mechanism. A source-code study of eleven coding agents published in July 2026 read around four million lines across Claude Code, Codex CLI, Gemini CLI, Aider and seven others, and found that anatomy in every one of them, assembled directly rather than on top of a shared framework. The loop is settled engineering, and the rest of this page is about what goes around it.

The people who build the models went first

Anthropic's chief executive said in March 2025 that AI would be writing 90 percent of code within three to six months, which read as a stretch at the time (Business Insider). By January 2026 an Anthropic spokesperson put company-wide AI-written code at 70 to 90 percent, and around 90 percent for Claude Code itself, which makes the coding tool largely the work of the agent it ships. In the same report, the engineer who built that tool said he shipped 22 pull requests in a day and 27 the day before, each one written by Claude, and that he no longer makes small edits by hand. A researcher at OpenAI said the same of their own work. These are the people with the most information about what the models can do, and the direction they moved is the useful signal.

One loop has a ceiling

Everything an agent has read, run and said sits in one context window, and Anthropic's engineering team stated the consequence in September 2025: as the number of tokens in that window grows, the model's ability to recall what is in it falls. They call it context rot, and the arithmetic behind it is ordinary attention, where every token relates to every other one and the relationships grow as the square of the length. Past a certain size of job, one loop cannot hold the whole thing, so the work gets split.

Splitting needs a written plan

The split is where the measurable losses are. A study of multi-agent code generation, revised in January 2026, traced 75.3 percent of failures to the gap between what a planning step wrote down and what a coding step read, and found that rewording a requirement without changing its meaning broke up to 83 percent of the problems the same system had already solved. So the plan names the files, the tasks and what counts as done for each, because whatever reads it next will take it literally.

What the specialists do

A plan is handed to specialists, and the word coding undersells the roster. A specialist is defined by three things: the brief it is given, the tools it may touch, and the context it starts from. None of those is about writing code. So one run carries a researcher that reads the system and reports what is actually there, another works a design up against the tokens the product already uses, others implement, one reads diffs and nothing else, one writes the documentation, one looks for a single class of security problem. Each returns its findings and leaves the rest behind, which is how a long investigation costs the plan a paragraph instead of its whole context.

The industry made this portable during 2026. Anthropic published Agent Skills, a folder of instructions and scripts that teaches an agent one job, and on 22 October 2026 donated the standard to the Linux Foundation's Agentic AI Foundation, alongside contributions from OpenAI, Hugging Face and Alibaba. The Foundation's own description is the breadth in one line: skills package instructions, scripts and resources so that specialized know-how is portable across agent products and platforms. Anthropic's 2026 report carries what that looks like away from engineering. Their legal team cut marketing review turnaround from two or three days to 24 hours, and a lawyer with no coding experience built the tools that triage issues before they reach the legal queue. At Zapier, design teams prototype concepts live during customer interviews.

Parallel work holds when the writers are isolated

Two agents editing the same working copy overwrite each other, and isolation is the part the industry converged on first. Cognition shipped git worktree support in December 2025 so several sessions could run in one repository without conflicts, and in March 2026 published a lead agent that splits a task across parallel sessions, each one in an isolated machine with its own terminal and files, with the lead reading the full trajectory of every session it started. Anthropic's batch tooling hands each of its subagents a worktree of its own. The practice is the same in both, and it is the one we run: parallel building, each thread on its own branch, each change kept small enough for the next step to judge whole.

Something has to attack the result

Agreement between agents is cheap. A paper published in August 2026 showed cooperative agents drifting into false consensus, where agreement stands in for evidence, and showed a coder working with a reviewer and a dedicated critic scoring higher on correctness than a larger group working cooperatively. What makes the review useful is a fresh context. A reviewer that sees the diff and the acceptance conditions, and not the reasoning that produced the change, judges the result on its own terms. Anthropic runs this arrangement as a product, dispatching a team of agents per pull request that verifies its own findings before reporting them, and it became generally available in October 2026. A critic that sends a round back is doing its job, and a run where nothing comes back is the one worth looking at twice.

One point of integration

Parallel work from a single plan still carries small divergent choices. Cognition's June 2025 essay put the rule in one line: actions carry implicit decisions, and conflicting decisions carry bad results. Those choices get reconciled at one assembly point, and what leaves is a single reviewable pull request with its tests and checks attached. Google's DORA research lists strong version control practices and working in small batches among the seven capabilities that amplify what AI does for an organisation, and one reviewable pull request carries both.

Where people sit

You brief us. We design the architecture, run the work and own planning, quality and acceptance. The published record is specific about why the human part stays large. Anthropic's 2026 report on agentic coding measures developers using AI across roughly 60 percent of their work while fully handing off between zero and twenty percent of tasks, and names the shift as one from writing code to reviewing, directing and validating it. A September 2026 study that observed nineteen experienced developers found the supervising itself becoming engineering work: effort concentrated in planning, recurring guidance turned into reusable assets, and checking handed to agents built for checking. Stack Overflow's 2026 survey of more than thirty thousand developers gives the reason people stay in the loop: close to half trust output they can verify, and 6.6 percent trust it for decisions that matter. Verification is what these steps manufacture, and the judgement about what is correct and what ships stays with people.

Andrej Karpathy, who named vibe coding a year earlier, spent his April 2026 Sequoia talk drawing the line away from it. Vibe coding raises the floor and lets anyone describe software into being; agentic engineering raises the ceiling, and he defined it as the professional discipline of coordinating fallible agents while preserving correctness, security, taste and maintainability. The line he kept coming back to was one he had read somewhere: you can outsource your thinking, but you cannot outsource your understanding. That is the job we keep.

What you receive

Ordinary pull requests in your repository: code, tests and documentation that stand on their own, in your stack and your conventions, reviewed before you see them. Your contract is with us alone, and we own planning, quality and acceptance under it.

Some work is better done the conventional way, written by hand and reviewed the way it always was, and clients ask for exactly that. We take it on the same terms, with the same people answering for it. The approach above is what we reach for when a backlog is wide enough to be worth running in parallel; the choice is part of the first conversation, and we say which one a piece of work is getting.

Where the evidence stops

Two findings keep a figure off this page. METR's trial in July 2025 found sixteen experienced developers 19 percent slower with AI tools on repositories they knew well, while they believed they had been faster. METR's own follow-up in February 2026 withdrew that headline rather than replacing it, because participants had begun declining tasks they did not want to do without AI, which broke the measurement. And Google's DORA report for 2025, across roughly five thousand professionals, found software delivery stability still negatively related to AI adoption. So this page describes the shape of the work, and the numbers stay with the people publishing them.

How this came about

The approach assembled in public, release by release. What was an open argument in the summer of 2025 is a published standard a year on, and the dates are the argument for calling it one.

Jun 2022
GitHub Copilot reaches general availability
Oct 2022
ReAct pairs reasoning with acting in one loop
Mar 2023
AutoGPT lets the loop generate its own sub-tasks
Oct 2023
SWE-bench measures agents on real repositories
Mar 2024
Devin is announced, resolving 13.86 percent of SWE-bench unassisted
Nov 2024
The Model Context Protocol makes tools an open standard
Feb 2025
Claude Code moves the loop into the terminal
Jun 2025
Two essays a day apart argue opposite sides of parallel agents
Sep 2025
Context engineering names the window as a budget
Dec 2025
Git worktrees ship, and parallel writing gets its isolation
Mar 2026
A lead agent delegates to parallel sessions and reads their traces
Oct 2026
Adversarial review reaches general availability
Oct 2026
Agent Skills, the format for a specialist's know-how, becomes a Linux Foundation standard

Sources

If this is how you want software built for you, write to hello@ferneri.com and tell us what you are building.

All articles