Agentic Development and The Enterprise

From Industrialization to Executable Governance

“If you define your role as a software engineer as how quickly you type into your IDE, the next few years might leave you behind… Instead of coding faster, engineers should focus on what to build and how to guide these systems.” — Satya Nadella, CEO of Microsoft

I started my career two decades ago as a lone programmer writing scripts and small Windows and web applications. I was working for a company at the time that was in the software-adjacent field of data entry and digitization, and they needed automation. I moved on to software companies and then consulting. From junior developer in a small team to a senior one, to a team lead, then to an architect and senior architect. My journey is typical for a 20-year veteran of the field. And before generative AI, the path was clear. As more companies demanded software and the difficulty of writing code increased, it became imperative to industrialize the process.

I recently read a book on the production process and the history of manufacturing (The origins of efficiency), and I can see clearly the direction our industry was heading before the ChatGPT AI moment. A typical software project would be led by a project manager to manage deliverables and client interactions. One or more business analysts will handle the client's requirements. And one or more UI designers to ensure the software's look and feel adhered to the client's UI standards. You would have a solutions architect to design the technical solution. You would have a team of developers, from Juniors to seniors, and a team leader, to write the software. And finally, you would have a team of testers to test the software. This was not inefficiency; it was a rational response to scarcity—scarcity of skilled engineers, scarcity of compute, and scarcity of fast, low-cost iteration. This is the Ford Model-T assembly line of the software sausage. It was a contingent optimization. We organized work this way because we had to.

As I moved from Cloud Architecture to Generative AI engineering and architecture, I went from using the chat interface to help me code to using ChatGPT to request scripts and code sections. To code edits and helpers in the early GitHub Copilot. To the latest generation of tools like Claude Code and others, powered by Claude, GPT, and others. Today, Anthropic’s latest Claude model shines in coding and agentic coding. This is where you specify intent, constraints, and tests, and the agent produces and iterates on the implementation.

In the hands of a novice, these tools can lower the barrier to entry. In the hands of a capable engineer, they fundamentally change how software is produced. The question that follows is not whether developers become more productive, but what happens to the surrounding structure that industrialization created. What becomes of the layers whose purpose was to translate, constrain, and coordinate work across scarcity?

This question brought me back to my first job and the first year, when I was the sole developer creating scripts and tools for CAD operators to use. It was only me doing the coding, and I would iterate with the users directly to create them. Those scripts were small by today’s software standards, and so I could iterate fast with my client.

Enterprise software is, of course, far more complex. It operates under regulatory constraints, long system lifetimes, and non-trivial blast radii. Yet agentic development changes a key variable: iteration speed. When software can be produced, modified, and tested quickly, the cost of modular experimentation falls dramatically. Instead of freezing requirements upfront and optimizing a process to deliver them months later, functionality can be built incrementally, validated with business users, and adjusted while the context is still fresh.

This does not eliminate architecture or governance; it changes where they live. Many of the constraints historically enforced through documentation and review—approved libraries, mandated stacks, legacy integration patterns—exist to manage risk over time. Agentic refactoring does not eliminate these concerns, but it reduces the irreversibility of decisions. When systems can be reworked with lower marginal cost, stack choices and interface constraints become less permanent, and governance can shift from pre-emptive restriction to continuous verification.

In this model, architecture becomes executable rather than declarative. Tests, policies, and constraints are expressed directly in code and continuously exercised by agents that generate, refactor, and validate implementations. Quality assurance becomes adversarial and ongoing, with agents testing agents, rather than a late-stage gate. Compliance and auditability move from static documents to traceable execution paths that can be replayed and inspected.

This inevitably compresses roles, but compression should not be mistaken for elimination. The responsibilities of the architect, senior engineer, and quality engineer converge into fewer operators who are accountable end-to-end, supported by automated systems rather than human handoffs. Accountability does not vanish; if anything, it becomes clearer. Someone still owns the outcome when things fail. What changes is that ownership is exercised through direct control of the system, not through layers of translation.

Crucially, this shift is not uniform across all domains. In high-risk, tightly coupled systems—such as core banking platforms, billing engines, and patient records—industrialized processes will persist, albeit internally accelerated by agents. In medium‑risk, modular domains—internal tools, analytics pipelines, workflow automation—role compression and direct business‑to‑software iteration are already viable. In low-risk, ephemeral systems—such as reports, simulations, and decision support—the traditional production model is likely to collapse almost entirely.

The primary gain here is not a simplistic notion of tenfold productivity. It is the reduction of coordination failure and the shortening of the distance between intent and execution. Fewer translation layers mean fewer opportunities for meaning to be lost, delayed, or distorted.

Over the long run, maybe the intermediary will be cut out completely, and computers will execute functions on the fly. You want a valuation for the top 200 companies in the S&P 500; your agent will spit it out in seconds and present it well for you. It can do it now, but much slower and with a risk of hallucinations. But in the next few years, depending on who you ask, the problem might be solved (I am in the pessimistic camp on AGI, though Artificial Neural Networks – but that’s another conversation).

The process might be gradual. Enterprises will not abandon industrialized software development wholesale, nor should they in some cases. But in every domain where risk can be bounded, they should move authority closer to those who can express intent precisely, enforce constraints programmatically, and iterate rapidly. Organizations that learn where industrialization remains necessary, and where it has become friction, will not merely build software faster. They will think and adapt faster than those who do not. This is a wake-up call: We need a new Vibe Engineering Manifesto.