A SaaS team climbed six levels of AI development and stopped at L4, where agents build features
A mature SaaS company spent more than a year adopting AI and mapped the path into six levels, from manual work at L0 to the "dark factory." The team stopped at L4: agents build features end to end, while people build the system that ships them. The lesson is that you cannot skip levels. An agent without tests, CI, and an AGENTS.md rules file has nothing to check itself against. So start with checks and team rules, not with buying an agent.
AI-processed from Habr AI; edited by Hamidun News
Many teams have already bought an AI assistant subscription but cannot say what stage they are at or what is holding them back from moving forward. The author of the Habr analysis has been introducing AI at a mature SaaS company for more than a year. The engineering team there was initially skeptical of neural networks. He immediately clarifies that this is not vibe coding and not a product built in an evening with a single prompt. He calls his work AI engineering: the team builds a system that consistently delivers results that meet its quality standards.
The author breaks the path into six levels. L0 is manual development, L1 is working with an assistant, L2 is working with an agent, and L3 is delegating to an agent. At L4, agents build features end to end, and this is where the team stopped. It is currently experimenting with a semi-autonomous agent factory in the cloud. The final level, the "dark factory," completes the scale.
L0 and L1: from manual work to a chat advisor
At L0, people do everything. The spec is a page in Notion, and the implementation plan lives in the developer's head. Some services lived without pull requests and reviews: commits went straight to master. QA checked things manually on a shared staging server against the original spec, which could become outdated after implementation. But there were Playwright tests, and some projects had good test coverage and static analysis. The author considers this a valuable foundation: CI is critical for agentic development.
At L1, a ChatGPT subscription appears, and autocomplete arrives in the IDE. It is like a wise colleague at the next desk: they advise on how to design a feature, sketch a spec, explain code, and write simple scripts. The developer copies the result into the IDE and presses Tab and Accept. Tasks get solved faster, but essentially nothing changes. The chat has no access to the team's artifacts and no tools to act beyond the conversation. Dan Shapiro compares this level to lane keeping and cruise control.
L2: the agent as a junior you have to train
At L2, a real agent arrives, such as Claude Code or Codex. It already changes files in the repository: it writes specs and code. But it codes like a mediocre junior, that is, the way the internet writes code, not the way your team does. For demos this is enough, but with real users everything starts to fall apart.
So the team teaches the agent the rules:
- each repository has a short AGENTS.md with rules, architectural boundaries, patterns, and domain knowledge. The format was released by OpenAI in 2025 and is now governed by the Linux Foundation;
- the file that has grown too large is split into parts that the agent loads as needed;
- for every recurring "mistake" the agent makes, a human writes a rule;
- the agent is given tools: check scripts, MCP servers with a knowledge base, production logs and Sentry, and a browser;
- recurring tasks are turned into skills.
Quality gates are no less important: build, tests, static analysis, and architectural boundary checks. Without them the agent is blind: it gets no feedback and does not catch its own regressions. That is why the agent's changes go only through pull requests with CI and review. Trunk-based development without review worked while people wrote the code, but it does not suit agents.
The developer's work shifts from writing features to building the system that writes them: launch the agent, look at the result, adjust the instructions. QA hands the agent deterministic browser scenarios, while people keep the creative part: questioning requirements and scrutinizing design and UX. The knowledge base must not only be filled but also cleaned: models get stronger, and some of the hints are no longer needed.
What changes at L3
At L3, personal practices become a shared process. The author lists practices for the organization: shared skills and processes in one registry where each item has an owner; procedures written as skills (PR format, ticket links, QA tickets); and a label for AI work on every change, so you can see how much the agents are doing. This is how the whole team's work with agents becomes uniform.
Why this matters
The main takeaway of the analysis: you cannot skip levels. Without CI and mandatory gates, an agent has nothing to check itself against. Without AGENTS.md and team rules, it writes "like the internet." Without shared skills and owners, each developer invents their own process. If you want to reach agents that build features end to end, first check the foundation: version control, pull requests, tests, and static analysis.
There is also a caveat: this is the experience of one team at one SaaS company, not a universal study. The semi-autonomous factory in the cloud remains an experiment for now. Still, the six-level scale offers a simple way to understand where you are today and what you need to do to climb to the next level.
- Nov 21, 2026FDE job postings grew 4.6x in a year: what a forward deployed engineer actually does at the client's site
- Nov 21, 2026A swimming team captain handed ChatGPT three scheduled tasks and cut her routine work by a multiple
- Nov 21, 2026OpenAI GPT-6 Cyber Found About 35 Flaws in iPhone, Mac and Other Apple Devices
- Nov 21, 202622 Claude Agents Spent Six Weeks on Black Hole Problems — and Solved Two
Key Questions Answered
What are the key details on L0 and L1: from manual work to a chat advisor?
At L0, people do everything. The spec is a page in Notion, and the implementation plan lives in the developer's head. Some services lived without pull requests and reviews: commits went straight to master. QA checked things manually on a shared staging server against the original spec, which could become outdated after implementation. But there were Playwright tests, and some projects had good test coverage and static analysis.
What are the key details on L2: the agent as a junior you have to train?
At L2, a real agent arrives, such as Claude Code or Codex. It already changes files in the repository: it writes specs and code. But it codes like a mediocre junior, that is, the way the internet writes code, not the way your team does. For demos this is enough, but with real users everything starts to fall apart. So the team teaches the agent the rules: each repository has a short AGENTS.md with rules, architectural boundaries, patterns, and domain knowledge.
What changes at L3?
At L3, personal practices become a shared process. The author lists practices for the organization: shared skills and processes in one registry where each item has an owner; procedures written as skills (PR format, ticket links, QA tickets); and a label for AI work on every change, so you can see how much the agents are doing. This is how the whole team's work with agents becomes uniform.
Build & Ship Production AI Agents Without Boilerplate Code
Start your free 72-hour trial at Hamidun Academy (academy.hamidun.com) — interactive lessons on Claude Code & Cursor, live Tech Radar, and production agent templates.
The AI world, distilled — once a week
Seven stories that actually mattered, hand-picked. No noise, no reposts, no press releases.
Done! Check your inbox for a confirmation.