In business applications, the scarce resource is no longer the developer. It is the person who knows the business and can say exactly what the system must do.
Jeff “Cheezy” Morgan recently wrote a good post called Scaling the New Team. His main point: AI agents now do much of the building, so the bottleneck has moved from writing code to deciding what to build and judging what was built. He proposes a small team of three people: one subject-matter expert (SME) who owns requirements and context, and two engineers who review the agent output.
I agree with the analysis. But for business applications, I would go one step further. I think the ratio should be the other way around. We need more SME capacity than developer capacity.
The bottleneck has moved
For 30 years, writing code was the expensive part of a software project. We had analysts, but most of the budget and most of the people went into implementation. Requirements were often a short document, and developers filled the gaps while coding.
With AI coding agents, this has changed. An experienced developer with good agents can implement a well-written use case in minutes, not weeks. In my own setup, implementing a use case takes between 15 and 60 minutes. The code is no longer the slow part.
What is slow now:
- Knowing what to build. Which business rules apply? What happens in the exception cases? Who is allowed to do what?
- Writing it down precisely. An agent does exactly what the specification says. A vague sentence becomes vague code.
- Judging the result. Is this really what the business needs? Does it work with real data and real users?
All three are SME work. If one SME has to do all of this for two developers with agents, the SME becomes the limit. The developers wait, or worse, they guess.
Why business applications are different
In most business applications, the domain is much more complex than the technology.
The technical side is well known. A typical Java stack with a server-side rendered UI or a single-page application and a relational database has been built many times. Agents know these frameworks very well. The patterns for forms, grids, validation and persistence repeat in every project.
The domain side is never the same. Think of a payroll system, an ERP or an application for a public authority. There are laws, internal regulations, special cases that grew over 20 years, and knowledge that exists only in the heads of a few people. No agent knows that your company calculates holiday pay differently for part-time staff who joined before 2015.
So in business applications, the hard questions are almost always domain questions. And domain questions can only be answered by people who know the domain.
What I see in my projects
This is not theory. I am currently working in several projects, and I see the same pattern in all of them, just in two different forms.
Project A: two SMEs and one developer. In one project, the team is two domain experts and me as the only developer. A few years ago, this setup would have looked strange. Today it works very well. The two SMEs clarify the business rules, write and review the use cases, and test the results. I turn the specifications into code with the help of agents. I am rarely the one who slows the team down. When we wait, we wait for a decision from the business, not for code.
Projects B and C: the developers are the SMEs. In other projects, there are no dedicated SMEs. The developers know the domain well and do the requirements work themselves. Here the shift is visible inside each person. About two thirds of their time now goes into SME work: clarifying requirements, writing specifications, talking to users, checking results. Only one third is classic development work, and most of that is reviewing agent output.
Both setups tell the same story. Whether you count people or hours, the work in a business application team has moved towards the SME side. Roughly two thirds SME work and one third development work.
Not just any SME
More SMEs only help if they can produce specifications that an agent and a developer can work with. Two people who know the business but cannot write down the rules clearly will not solve the problem.
The SME of the AI era needs two skills:
- Domain knowledge. They know the business, the rules, the exceptions and the people to ask.
- Specification skills. They can turn this knowledge into precise, testable artifacts: requirements, use cases with alternative flows, business rules, an entity model and a glossary.
Few people bring both from the start. But the second skill can be learned. This is why I am a strong advocate of Spec-Driven Development and why I created the AI Unified Process. It gives SMEs a clear structure: what to write, in which order, and at which level of detail. The specification becomes the main artifact, and the code follows from it.
In practice, a good combination is often one domain expert plus one requirements engineer or business analyst. The domain expert brings the knowledge, the requirements engineer brings the structure. Together they produce specs that are good enough for agents.
But who reviews the code?
There is a fair objection. Morgan has two engineers for a reason: they review the agent output and each other. With only one developer, nobody checks the checker.
I take this seriously. Agent output must be reviewed, and a single developer is also a risk when they are sick or on holiday. Some ways to deal with it:
- A shared technical lead. One senior developer reviews across several small teams and keeps the architecture consistent.
- Strong automated checks. Tests derived from the use cases, architecture tests, static analysis and a CI pipeline catch a lot before a human looks at the code.
- Specs as the review basis. When the specification is precise, the review gets easier. You check the code against the spec, not against your memory of a meeting.
Most important: reviews must be risk-driven. Not every line of agent code needs the same attention. A screen that only lists data is low risk. A calculation that affects money or an access rule is high risk.
Here the SMEs help again. They know which parts of the business are critical and which are not. Together, SMEs and developers decide where a deep human review is needed and where automated checks are enough. This way, one developer can spend the review time where it really matters.
I also do not say that the 2:1 ratio fits everything. For technically heavy products like platforms, infrastructure or high-performance systems, more developer capacity still makes sense. My claim is about business applications, where the domain is the hard part.
What this means for your team
If you build business applications, here is what I recommend:
- Plan for more SME capacity than developer capacity. Two SMEs and one developer is a good starting point for a small team.
- Free your domain experts. An SME who spends one hour a week on the project is not an SME on the team. The business must give real time, not just availability for questions.
- Invest in specification skills. Train your SMEs and developers in requirements engineering and use case writing. This is now the most valuable skill in the team.
- Let developers grow into the SME role. If your developers know the domain, accept that most of their work is now specification and validation. This is not a loss. It is where the value is.
- Measure the waiting time. If developers wait for decisions, you have too little SME capacity. If specs pile up, you have too little developer capacity. Adjust the ratio based on what you see.
Conclusion
AI did not make developers less important. But it made code cheaper, and when code is cheap, the expensive part is knowing what the code should do. In business applications, that knowledge sits with the SMEs. So we should staff our teams that way.
Keep IT simple: put your people where the bottleneck is.


