Coding agents still need human judgment. One example I run into often is that they tend to write code for everything instead of using an existing library that is already battle-tested. That is why you need gates and oversight in your agentic development setup where you can review agents’ artifacts, understand what they are going to do, and intervene before they create issues downstream.

Faster code is not faster delivery.

Coding agents are still not very good at designing systems and working on complex software systems. So software factories will not suddenly make coding autonomous - or make building large systems fully autonomous. At least not now. I think software factories should be thought of as a team of agents that sits with your software development team. In some cases, agents can take over almost everything and you may not need to do much. For example - writing code, fixing errors, writing test cases, running tests, etc. But in more complex cases, agents will pull together all the available context and come back with their best effort. You will still need to nudge them, steer them, and sometimes make the final call. You can have an Architect Agent assisting you, maybe backed by skills that encode how you think systems should be designed. It can understand the context, analyze trade-offs, and propose the architecture. But you may still have to take the call. One simple example - if you are a startup, you may deliberately not want to solve every scalability or architecture problem today. An agent may design for the "ideal" system, while you know some of those problems do not need to be solved yet. That judgment still matters. This is also how I think a software factory should fundamentally be designed. You have a team of agents. Each agent has a clear responsibility, and agents are talking to each other, sharing context, and working together towards the larger goal. Today, some of those responsibilities may still need human assistance. An Architect Agent may own architecture, but a human may still need to steer it or take the final call. The important part is that the responsibility belongs to the agent, while humans assist and steer wherever needed. We are not going to become autonomous all of a sudden. It will be a journey. I like the idea of thinking about this as an autonomy slider, as proposed by @karpathy. Today, the slider may be high for some responsibilities and low for others. As models get better, context management gets better, and the infrastructure around agents improves, that slider can keep moving towards more autonomy. So for now, a software factory should be thought of as autonomous for some parts of software development, and human-steered for others. Fundamentally, a software factory is a meta-harness where - agents have clear responsibilities, - agents have access to the right context needed to perform their responsibilities, - agents can communicate and work with each other, agents work autonomously where they are capable, - work can be gated where human judgment is needed, an accountable owner can nudge and steer agents at any point, - agents can verify their own changes, - agents can learn and get better over time, - everything runs on top of a robust governance layer. The architecture should not assume humans will always be required at every step. The idea is to build the software factory in a way that lets you keep moving the autonomy slider as agents get better. This is what I am building prinevo.ai

Context, governance and learning primitive for agents has to be baked into platform primitives on day0 if you want to build an agentics system which eventually becomes autonomous.

The way collaboration happens in the SDLC will have to change. It has to become much more real-time. Earlier, we used to brainstorm, plan, come up with design docs, discuss contracts, and then start building. This process gave everyone time to align and think through what we were building, how we would build it, and what the impact would be. People had the time and context they needed to make good decisions. With agents, the pace is completely different. You think of an idea, and someone can raise a PR within 30 minutes. Teams are struggling to keep the system aligned because the speed of execution has fundamentally changed. The way collaboration happens has to change as well. It has to become real-time. That means we need a platform where humans and agents can collaborate together in real-time. You have a product idea. You spin up a PRD, brainstorm with agents that have all the relevant context, and other team members can participate in the discussion as well. Once there is alignment, you approve it. Then you move to architecture, where the team and agents work together to think through the design and trade-offs. Only then do agents move to implementation. You can still have quick experiment tracks, but if you want a reliable, resilient, and extensible system, then you have to think through how the system will evolve. And all of this is gated, so humans remain in control of how the system evolves. It doesn't become a mess. As confidence improves, the amount of human oversight can gradually reduce. But the core idea remains the same: real-time collaboration between humans and agents to ship software requires a fundamentally different platform—one that is AI-first and has a strong context layer at its core. This is what @helloprinevo will solve for.