AI-Native Software Development: From One Agent to a Software Factory
By Sam Wen, CEO & Founder of XInfer.AI — November 22, 2026
AI can now do most of the work of building software. Two things may never move to AI: understanding the work, and the authority to decide what happens next. We built a page and an assistant to help people keep up their understanding, so they can make those decisions well.
What we handed to AI, and what we can't
At XInfer, AI writes the code and reviews it. It also writes the intent documents, the specs, the tests, the deployment code and most of the end-to-end tests, and it wires them together.
Two jobs are left, and we may never be able to hand them over:
- Understanding. Knowing what the system does, what changed in the field, and what a choice will cost.
- Authority. Setting the direction and making the final decision.
I wrote about authority in The Machine Runs, the Driver Decides. Understanding comes first, because every decision depends on it. If you don't understand a change, your approval means nothing.
The field moves faster than anyone can read
Keeping up is now hard work. We keep a timeline of the main sources on AI-native development. It has 30 entries. Fifteen of them came out after my July essay on automated gates (The Model Codes, the Gates Decide).
Two of them show the scale. Last month, Anthropic reported that its merges a day went from about 2,500 to over 30,000 in four months. It built new source control to keep up (Redesigning source control at Anthropic). Earlier this month, GitHub described a test with "5,000 concurrent agents working on a repository" (Inside GitHub's new Git storage architecture).
An essay doesn't change after it's published. On this topic, that is a problem.
A page that keeps up, and an assistant you can ask
So we built a free, public page on AI-native software development. It is based on what the major AI companies and open-source projects have published.
The page has three levels:
- AI-assisted coding. One agent helps with one problem at a time.
- Parallel AI development. Several sessions run at once, each in its own worktree.
- AI-orchestrated development. A system splits a goal into tasks, runs them and checks the results. People approve the important steps.
Each level goes through six stages: planning, design, building, testing, deploying and maintaining.
You don't need to read the page. At ai-native.xinfer.ai, an assistant answers questions from the page and from the research notes behind it. You can type or talk to it. When you type, it cites its sources. You don't need to sign in.
One question and its answer
We asked the assistant this question in a new chat on November 19, 2026. Here is its answer, exactly as given.
The question: How many parallel sessions can one developer run?
Most sources put the practical limit at about two to five sessions. Anthropic's playbook suggests starting with two or three and adding more only while review keeps up [r-1]. OpenAI's engineers found most people could comfortably manage three to five before context switching became painful [r-2]. Some individuals go higher; Peter Steinberger runs three to eight in one folder [r-1].
The limit also depends on the codebase. XInfer's own measurement of 1,594 merged pull requests found that, as the work was split, about two sessions could run at once [r-4].
Would you like more detail on any of these sources, or on how to measure the limit for your own codebase?
The answer cited two sources:
- [r-1] and [r-2]: our notes on parallel sessions and orchestration. The page sums them up under Level 2: Parallel AI development.
- [r-4]: our measurement of XInfer's codebase. The page covers it in its case study.
The answer offers to explain how to measure the limit on your own codebase. Try that as your next question.
When you ask, your answer will be worded differently. It should rest on the same sources.
AI can make mistakes. Typed answers cite their sources, so check what matters to you against them.
How it stays current
A program now runs every day. It does the reading that nobody has time to do:
- It follows the field. It checks the pages, repos and feeds we cite, and looks for new publications.
- It uses conversations to find gaps. It grades the assistant's answers. When a question shows a useful gap in our research, it looks for sources to fill it.
- It records what's new. Two files list what changed, by day and by week. The assistant reads them, so you can ask what's new today, this week or this month.
We started this research on November 13, 2026. The page shows the date it is current to. When we publish a new version, the assistant answers from it.
The assistant is XInfer's own product, the same AI agent our customers put on their websites. Here it answers from this research.
What stands behind the answers
A system that reads the web can pick up bad sources, by accident or on purpose. A page can also hide instructions for AI readers. So we check every new source before we use it, and we keep checking the sources we already cite.
The page has its own checks:
- Each claim about a company's work is labeled. Read means we read the company's own page, post, paper or documentation. Reported means we have it only from news or other secondary sources. Repo means we checked it on GitHub.
- A script checks every link and quote on the page against our notes each time we publish it.
- If we can't read a document, we record that, what we used instead, and how to get the original.
- The page lists the problems nobody has solved yet. There are 8 right now.
These checks make a wrong answer less likely. They can't prevent every one.
Where a person still decides
AI does most of the reading and checking here. A person sets the direction and the rules, and makes the decisions that matter. For example, when a new source contradicts something we published, a person decides what happens next.
Three questions to start with
The decisions in your work stay with you. These questions can help you understand what you are deciding. Pick the level you work at, and ask one of these:
- One agent: "How do I stop Claude from changing a test to make it pass?"
- Parallel sessions: "How do I keep parallel agents from overwriting each other?"
- A software factory: "What happened when Anthropic ran 16 agents on one compiler?"
Then ask a follow-up.
Try the AI agent at ai-native.xinfer.ai. Type your question, or press Voice chat and ask it out loud.