The software factory after the prompt
AI made the first draft cheap. The enterprise problem is making every change reviewable, secure, and connected to the business that owns it.
The next software bottleneck is governed coordination, not generation.
Open the takeaways ↘
- ↳The accountable change, not the generated output, is the unit of trust.
- ↳Admission is the first security boundary; deployment is the last.
- ↳An outside coordinator can track progress through clear agreements without receiving proprietary source.
Sections
The first draft is no longer the finish line
The phrase ‘AI-assisted development’ still makes many enterprise conversations sound like a faster version of autocomplete. That description is now too small. A capable agent can read a repository, form a plan, call tools, change several services, run tests, open a pull request, and continue operating while its human operator is doing something else. The scarce resource is no longer the ability to produce a plausible first draft. It is the ability to let that draft enter a real organization without losing ownership, context, or the ability to explain what happened.
That distinction matters because enterprise software is not judged at the moment a model prints code. It is judged when a customer relies on the result, when a security team asks which identities could reach production, when a compliance reviewer asks for evidence, and when an incident commander needs to reconstruct the chain of decisions under pressure. A generated change can be technically correct and still be operationally unacceptable if nobody can say which business request authorized it, which business it belongs to, what data it saw, what permissions it exercised, or who accepted the remaining risk. The output is not the unit of trust. The accountable change is.
What is an enterprise software factory?
An enterprise software factory is the system that turns a business intention into a released, operated, and reviewable software change. It includes the visible tools (repositories, issue trackers, CI, environments, scanners, model providers), but the tools are not the factory by themselves. The factory is the set of boundaries and handoffs that makes those tools produce a dependable outcome. It answers five questions for every piece of work: what are we trying to accomplish, who is authorized to act, what may the system touch, what evidence must be preserved, and what conditions permit release?
Agents make this operating model more important, not less. A human tends to create friction simply by being slow: they ask a question, wait for an answer, and notice when context is missing. Multiple agents can cross the same seam in milliseconds. That speed is valuable only when the seam is explicit. Otherwise the system compounds ambiguity at machine speed: copying an incorrect assumption into a plan, widening a repository scope, reusing a credential in the wrong workspace, or declaring success because a local test passed while the business requirement was never verified. The software factory therefore needs a governance layer that lasts even when its workers are disposable.
The governance layer is the missing layer
A governance layer is not another dashboard and it is not a central prompt router. It is the part of the system that decides what work is allowed. It ties a verified person to your business and a workspace; turns a request into a job with clear limits; hands out only the permissions that job requires; records each step; and refuses actions when the evidence or authority is out of date. The work itself can be fast and disposable because the governance layer is holding the identity, the scope, and the release decision.
This is the practical difference between an agent that merely acts and an agent that can be trusted with a consequential queue. The governance layer should be able to answer, without replaying an entire chat: which request created this run; which version of the plan was approved; which repositories, secrets, and environments were in scope; which agent and model acted; which tests and policy checks ran; which human or service approved promotion; and whether the final artifact is the one that was actually reviewed. These are not after-the-fact reporting fields. They are preconditions for safe execution. If the answer is missing, the correct behavior is not to guess: it is to stop, ask, or route the work back to review.
Security begins when work is let in, not at deployment
Most security programs still draw the important line at production deployment. For agentic software work, that line is too late. The blast radius begins when context is admitted. A repository URL, a pasted log, a ticket attachment, or a tool response can carry secrets, malicious instructions, or a misleading identity. The agent can make a security-relevant mistake while selecting a project, before it has written a single line of code.
NIST’s AI Risk Management Framework asks organizations to govern, map, measure, and manage AI risk across the lifecycle [1]. NIST’s Secure Software Development Framework similarly treats secure development as a set of practices integrated into the lifecycle, not a final scan [2]. The implication for an agentic factory is concrete: before the first agent step, the system must establish your business, who is acting, the purpose, how the data is classified, the repository scope, and the allowed tools. Each later permission should be narrower than the one before it. A build worker may read a checkout and write a branch; a release worker may propose a release but not approve its own risk; a compliance worker may assemble evidence without gaining access to the proprietary source it is describing. The factory earns speed by making these distinctions machine-checkable.
Learning loops need a trust boundary
The most ambitious software factories will contain learning loops: agents evaluate their own work, critique failed runs, update plans, and delegate to specialized sub-agents. That is where the architecture must become more disciplined. A learning loop should improve behavior inside your business without becoming an uncontrolled channel for proprietary data to an outside coordinator. The outer coordinator needs clear agreements, status changes, budgets, and outcome signals, not the customer’s source code, credentials, or private conversation.
This separation is more than a privacy preference. It limits what a compromised or over-curious coordinator can learn, makes vendor substitution possible, and gives the customer a defensible answer when an assessor asks where their data went. Agents inside your business can inspect the code and artifacts they are authorized to inspect; the coordinating layer can schedule work using run identifiers that reveal nothing private and permissions spelled out in advance. The boundary between them should be explicit enough to log and test: let in, running, waiting for review, failed with a clear reason, or ready for release. Recursive systems become safer when the loop can improve its policy and planning without silently expanding its authority.
Compliance should be a byproduct of operating safely
A PDF assembled at the end of a quarter is a narrative about a system, not necessarily evidence of what the system did. If the factory cannot connect a release to its originating request, its approved scope, its test results, and its actor-attributed changes, the reporting team is forced to reconstruct history from fragments. That reconstruction is expensive, slow, and vulnerable to omission precisely when the organization is under scrutiny.
The better design is an evidence trail created by normal operation. A run that is let in produces a permanent record of the original request. The permissions granted record what the agent was allowed to do. Execution events record what actually happened. Review and release produce decisions with an actor, a timestamp, and a version check. The released result carries a fingerprint of the source and the checks that were reviewed. None of these receipts prove that a system is safe by themselves; together they make the safety claim inspectable. This is the difference between compliance theater and operational evidence: the latter exists because the factory needed it to prevent an unsafe transition, not because someone remembered an audit deadline.
What Armalo is building
Armalo is building this as a working software factory: people define outcomes and retain authority; agents plan, implement, test, and explain; and your workspace boundary remains visible throughout the loop. The product is not a black box that asks a company to surrender its engineering judgment. It is a surface for governing work so more of it can run safely. The useful building blocks are mundane by design (workspace identity, permissions scoped to one job, isolated workspaces, a lasting record of each run, review gates, evidence receipts, and billing control) because those are the building blocks that keep a real business operating when the novelty wears off.
The external claim is therefore deliberately narrower than ‘AI writes your software.’ Armalo helps an enterprise build a software factory in which agents can be fast without becoming unaccountable. It lets the organization keep proprietary data inside your business while coordinating work through clear, inspectable agreements. It makes a good change easier to review, a bad change easier to stop, and a successful change easier to defend. That is the standard: not how much code the model can produce, but how much consequential work the business can trust the factory to carry.
A buyer’s test for agentic software
Before adopting an agentic development platform, ask for a walk-through of one complete change rather than a demo of one impressive generation. Start with the request. Show the verified person or account and the business it belongs to. Show the exact permissions granted. Introduce a deliberately failing test and a policy denial. Ask what the system records, what it hides, and how a second operator resumes the work. Then promote a small change and inspect the evidence without asking the vendor to prepare a special report.
The questions are intentionally uncomfortable. Can the system prove that an agent did not cross your workspace boundary? Can it distinguish a failed verification from a successful deployment? Can an outside coordinator follow progress without seeing the customer’s proprietary data? Can a human revoke a permission and know that in-flight work will fail closed? Can finance explain what a unit of agent work cost and why it was authorized? If the answer depends on a screenshot, a promise, or a future roadmap, the factory is still a prototype. If the answer is a durable receipt produced by the normal path, the organization has something it can operate.
Questions an enterprise buyer should ask
What is the difference between an AI coding assistant and an enterprise software factory? ↘
An assistant accelerates an individual interaction. A factory governs a complete change across identity, business scope, execution, review, release, and evidence. The difference is accountability over time, not model intelligence in one moment.
Does a governance layer require sending proprietary code to a central coordinator? ↘
No. A sound design keeps source, credentials, and learning inside your business. The outside layer can coordinate through clear agreements and progress summaries without receiving the data it does not need.
What should an enterprise measure first? ↘
Measure time to a trustworthy review, not raw agent activity. Track whether a run has a clear owner, bounded permissions, reproducible tests, explainable failure states, and evidence that survives the original operator leaving the room.
References
- [1]Artificial Intelligence Risk Management Framework (AI RMF 1.0) — NIST, 2023. A lifecycle framework for governing, mapping, measuring, and managing AI risk.
- [2]Secure Software Development Framework (SSDF) Version 1.1 — NIST SP 800-218, 2022. Outcome-oriented secure development practices integrated into the SDLC.
- [3]Secure Software Development Practices for Generative AI and Dual-Use Foundation Models — NIST SP 800-218A, 2024. A generative-AI profile for applying secure development practices.
Take this further
Want to test the argument against your own factory? Bring a real outcome into a room and inspect the next decision — with your AI Cofounder.
Next argument
Security is a property of the factory →