The Future of Software Engineering, Part 3: The Dawn of the Builder Age: Redefining Software Roles in an Agentic World
It seems that everywhere we look there are signs that artificial intelligence is transforming how we work on a daily basis. While some organizations are continuing to experiment with how to leverage the efficiency unlocks of AI, others have gone all-in: integrating agentic AI into their business operations to automate processes and workflows in every department.
Maybe you’re experiencing this at your own organization as leaders insist that you use AI in your day-to-day work, with loose definitions of success or KPIs to measure the effect. You’ve been left to fend for yourself, learning tips and tricks alongside your colleagues as you try and find opportunities for AI to bring value to your team. Or, perhaps you’re seeing the success story play out in real-time and have true value-added AI solutions bringing measurable benefit to the bottom line. As we continue to analyze where AI fits in our own organization and in the cybersecurity industry as a whole, we’ve decided to share our analysis, conclusions, and predictions in a series of articles. With our first two pieces, we established that navigating this new world requires a fundamental shift of the typical technology-first mindset. Rather than simply asking what AI can automate, we believe forward-thinking organizations must start by establishing what humans should remain responsible for, by design.
We made this distinction using a framework that categorizes the core skills of machines versus human beings. While AI excels at iterative, data-driven capabilities, captured by the mnemonic “INFER” (Identify, Navigate, Formulate, Evaluate, Recommend), humans continue to excel at the empathetic capabilities described by the acronym “VALUE” (Validate, Appreciate, Lead, Understand, Envision).
You can find our first article, laying the foundation for AI and Human capabilities, here: Why Humans Remain Irreplaceable in the Age of AI
And our second article, speaking to how career trajectories will shift and how to prepare ourselves, and our children, for the AI age, here: Navigating Career Evolution in the Age of AI
While we are witnessing the scaled implementation of AI play out across the entire corporate landscape in every industry, nowhere is this more visible than within the realm of software development. What started as an opportunity to leverage AI to assist with generating code has quickly evolved into integrating specially designed AI agents that can handle tasks across the Software Development Lifecycle (“SDLC”). By connecting these agents into an organized software development workflow, humans shift to become agentic “orchestrators,” training and refining them to optimize the process of designing, building, testing, and deploying software.
Armed with these new capabilities, we have entered what we call “The Builder Age,” where anyone with a clear vision, an understanding of user needs, and a grasp of basic system logic, is empowered to become a software builder. However, this democratization of software development does not render traditional engineering practices obsolete. Instead, it redefines the focus of every professional role within the software delivery lifecycle. To remain competitive, enterprise technology leaders must understand how traditional engineering roles are morphing into higher-order orchestrator functions.
Setting the Stage: From Autocomplete to Autonomy
To understand how rapidly the software landscape is shifting, one only needs to look at recent industry shifts to fold AI into the development process. Early iterations of generative AI focused on localized, "one-shot" tasks, acting essentially as a sophisticated “autocomplete” for engineering teams. Developers used AI to write a single isolated function, generate a basic test script, or debug a block of code. Now, builders have the ability to create multi-step, long-running workflows across the entire SDLC.
Today, a human developer can describe a high-level operational objective (such as adding pagination to an API endpoint or updating a complex web of deprecated open-source dependencies) and a coordinated squad of specialized agents can autonomously read the codebase, write the implementation, run local tests, iteratively fix their own execution bugs, present a fully realized pull request (PR), and deploy it to an environment.
This shift dramatically flattens the technical learning curve. Engineering teams are discovering that the historical silos dividing front-end, back-end, architecture, and infrastructure are collapsing. The developer’s core contribution is no longer hands-on-keyboard code creation; it is system architecture design, agent coordination, quality evaluation, and strategic problem decomposition. Plus, contributions from other roles - like Product Managers, Architects, and Data Analysts - are changing as well; all working together to integrate their agentic AI solutions into an autonomous software development pipeline to drive innovation in this emerging world.
Deconstructing the Shifting Technical Roles
To build an organization capable of scaling alongside AI technology, we must look closely at how individual roles have traditionally operated and attempt to forecast their evolution.
The Product Manager: From Developer Dependence to Real-Time Prototyping
In the Builder Age, product strategy becomes an even more vital upstream component of the software development pipeline. Rather than spending time exclusively writing requirements with their business stakeholders and discussing with their development teams, they will have the ability to accelerate prototype development using agentic AI to capture business feedback quickly. When product ideas have evolved to proven proof of concepts, Product Managers can then engage their development teams with everything they need to turn the idea into reality.
The Operational Shift:
The Existing World: The Product Manager spends weeks understanding a business request, performing market research, and writing requirements for their app or feature. Then, they engage with their development team to align on the desired user experience, data flows, edge cases, and layout requirements. The process may extend for long periods of time as developers dig into the requirements and form questions as they understand the architectural implications of a feature. Trade-offs are discussed to balance system stability with user delight, and the Product Manager communicates project timelines to the business as they understand the development team’s capacity and estimated effort. Then, after the feature or app is deployed, they’re left to reconcile their vision with the resulting product, iterating with the development team until their idea is fully fleshed out. This process can be a long and frustrating back-and-forth process.
The Emerging World: The Product Manager begins by scoping a product idea with their AI agent, providing requirements from their research, with a goal of producing a functional prototype to refine their idea before development effort even begins. After folding in advice from the other software-oriented positions involved in the process, including the Software Engineers, they prepare for a “roadshow” with business stakeholders and/or customer focus groups. After completing their prototype roadshow, they begin working with another AI agent to review feedback and refine the idea into clear, machine-readable requirements artifacts, including: explicit user behavior flows, acceptance criteria, and expected data flows. This product blueprint is instantly fed to a separate requirements-parsing AI agent that evaluates it for logical consistency, flags edge cases, and once the PM has signed off, the complete requirements package is handed off to coding agents to build the production-ready version.
Because Product Managers are able to leverage AI to build prototypes of their product vision, they can give business stakeholders the ability to quickly turn raw ideas into functional proof-of-concepts. This process will help ensure that only tested, validated product hypotheses will evolve into user stories in the development backlog. Furthermore, it ensures that the PM can effortlessly convert raw business feedback, market analysis, and Voice-of-Customer (VOC) data into comprehensive feature specifications that downstream AI coding agents can immediately ingest and execute.
Their focus shifts away from spending hours refining requirements with their dev team to accelerating the ideation process with the business itself. They’re able to take the time necessary to deeply Appreciate the user's experience, Envision the product’s long-term competitive path, and Lead business stakeholders to test their product ideas before building out a business case.
The Software Engineer: From Syntax Researcher to Coding Agent Orchestrator
For Software Engineers, the Builder Age is bringing upon a rapid pivot from manual code production to mastering the orchestration of AI agents that can take action on Product’s feature specifications. Rather than spending hours decomposing user stories, searching for appropriate 3rd party libraries, copy/pasting code, and tracking down bugs, Engineers gain the ability to act as the directors of automated AI delivery pipelines. When a validated product blueprint comes down the pipeline, they command their coordinated squad of specialized AI sub-agents to handle the technical heavy lifting, freeing them to focus on what they actually love: overcoming business challenges through creative system design.
The Operational Shift:
The Existing World: Software engineers spend an enormous amount of time converting intent into implementation. Although they routinely make architectural decisions and navigate complex trade-offs, their work is constantly interrupted by the mechanics of software delivery itself: learning business context, interpreting requirements, debugging systems, managing dependencies, writing repetitive implementation code, troubleshooting production issues, and coordinating across people and platforms. As a result, a large share of their creative capacity is consumed by the process of building software rather than by designing what the software should become.
The Emerging World: The Engineer begins by collaborating closely with Product to refine both functional and non-functional requirements. Rather than simply implementing feature requests, they help shape them by introducing considerations around security, scalability, performance, reliability, and operational complexity. Their understanding of how systems truly behave allows them to challenge assumptions, identify hidden dependencies, and ensure solutions will work not only today, but as the system evolves.
With a well-defined blueprint established, the Engineer then directs their dedicated squad of coding, testing, and security agents through implementation. Instead of manually translating intent into code, they inject architectural principles, AppSec protocols, coding standards, and performance guardrails directly into the automation workflow, upfront.
The AI squad generates code, creates and executes tests, performs security checks, and iteratively resolves defects before delivering a fully realized pull request that is then deployed for final testing and approval. While AI may pre-audit the output for consistency and compliance, the Engineer remains the ultimate authority to validate that the system genuinely solves the human problem it was intended to address.
The future of software development frees engineers from the manual grind of foundational code generation so they can scale their development impact without sacrificing software quality. Their focus is on building and continually optimizing a squad of agents, tuning the automated delivery harness, and ensuring that every piece of machine-generated logic aligns with their organization’s engineering standards.
Their core objective is no longer typing syntax, but rather mastering the art of end-to-end agentic software building. They have the bandwidth to Validate automated outputs at critical quality gates, Understand complex systemic failures under stress, and Lead the design choices that move the business forward.
The Enterprise Architect: Guarding against Architectural Drift
Enterprise Architects, who focus on planning for the next five years rather than only the next two-week sprint, will see the Builder Age turn design patterns into automated, mandatory rules. Architects do the heavy lifting of mapping data flows, ensuring scalability, and figuring out how complex cross-cutting systems interact with each other. In a world where AI agents can spin up thousands of lines of code in seconds, their role is the only thing standing between a clean platform and total chaos. Instead of fighting a losing battle to manually keep every team's code aligned with their company’s patterns, Architects now have the power to turn their system designs into automated rules that execute across every app and service in the enterprise.
The Operational Shift:
The Existing World: The Architect is responsible for the company's long-term technical health. They design clean system architectures, map out microservices, and set strict scalability standards. Yet, because human communication across large organizations is inherently imperfect, fast-moving development teams naturally drift from those designs. The Architect is forced to spend a massive chunk of their creative energy in review boards, acting as a reactive referee to catch anti-patterns, misplaced dependencies, and structural compromises long after the code has strayed into technical debt.
The Emerging World: The Architect’s design principles are no longer just reference guides on a wiki; they are built directly into the automated pipeline. The Architect sets up and trains custom topology agents that act as automated lookouts embedded right inside the active code review channels. If an AI coding agent or a human builder tries to push a change that violates a microservice boundary or breaks an API contract, the topology agent intercepts it instantly. It blocks the change, cross-references the Architect's blueprint, recommends a fix that fits the system design, and, based on confidence thresholds, brings the solution to the architect for a quick, final check before passing it back to be built correctly.
With Architects no longer spending their days playing catch-up to adjust sub-optimal technical decisions, they can finally focus on building what’s next. Instead of reacting to messy code after it’s written, they set up the strict rules and frameworks that keep the entire enterprise stack consistently clean.
Their day-to-day focus shifts entirely to the big picture: how systems connect, how to scale effectively, and where the tech stack needs to go next. They’re given the space and time to Envision the desired target state of their systems, Validate complex cross-system dependencies, and Lead the enterprise toward a bright, innovative technical future.
The Quality Assurance Engineer: Stress-Testing the Unexpected
For Quality Assurance (QA) Engineers, the Builder Age brings a shift from the repetitive grind of basic manual testing to orchestrating massive, automated testing engines. QA professionals will evolve to do the vital work of protecting the user experience at the pace that AI can write the code. Instead of spending hours upon hours writing test scripts or clicking through software checklists, QA Engineers will use AI testing agents to automatically verify functional correctness, simulate thousands of routine user paths all at once, and identify new edge cases based on the context of new features. This changes the role from a late-stage safety check to a proactive strategist who designs complex chaos scenarios that effectively stress test the application.
The Operational Shift:
The Existing World: The QA Engineer manually clicks through test environment applications with a checklist, enters predictable dummy data into form fields, and runs static smoke-test scripts. When issues are found, they dedicate significant time capturing screen recordings and writing detailed reproduction steps to log tickets. They are stuck in a defensive, slow routine, constantly behind, finding what’s broken after the code is built, often rushing to finish testing before a deployment deadline, with automated regression test development following weeks afterward.
The Emerging World: The QA Engineer switches to an offensive posture. They step away from manual execution because AI testing agents handle baseline functional verification while simulating obscure user paths at the same time. The human engineer manages these automated testing engines - refining their testing scope, validating their outputs, and manipulating variables to trigger edge- and abuse-case logic. They build automated chaos simulators, purposely cutting database connections, injecting network lag, and throwing corrupt data at the application to see how the system adapts and where the AI’s logic has blind spots.
Because QA Engineers no longer have to spend their days manually hunting down routine bugs, they can focus on making the platform bulletproof. Instead of just proving that a feature works in near-perfect conditions, they design automated simulations that expose what happens when everything goes wrong.
Their day-to-day focus shifts to the extremes: stress-testing system scalability, running advanced chaos simulations, and predicting systemic failure points. They’re given the capacity to Validate automated test coverage across millions of scenarios, to Understand how complex software behaves under heavy pressure, and Lead the strategy for product resilience.
The DevOps Engineer: Stewarding Autonomous Delivery
In the world of DevOps, the Builder Age introduces a massive firehose of automated code updates. When AI agent squads can write and attempt to ship software continuously, the core challenge shifts from "how fast can we deploy" to "how do we keep these autonomous agents from accidentally trashing production or running up a catastrophic cloud bill?" Rather than spending their days manually wiring CI/CD pipelines, writing IaC configs, or tracking down environment mismatches, DevOps Engineers transition into platform gatekeepers who control the blast radius of the company’s automated systems. They leverage AI to handle routine asset configuration and log analysis, freeing themselves to focus on building the secure, restricted sandboxes where autonomous workflows can safely run.
The Operational Shift:
The Existing World: The DevOps Engineer is responsible for keeping the software delivery engine running. While they design sophisticated infrastructure, pipelines, and deployment strategies, a significant portion of their time is consumed by maintaining the machinery itself: troubleshooting configuration drift, debugging deployment failures, reconciling environment inconsistencies, and responding to operational incidents. Too often, they are forced into a reactive cycle of maintaining systems rather than improving them.
The Emerging World: The discipline evolves from repairing pipelines to designing operational boundaries. Because AI can effortlessly generate infrastructure configurations, trace deployment failures, and execute operational tasks, the human engineer shifts their focus toward governing the environments in which those agents operate. They create structured, isolated execution layers where AI agents can safely provision resources, modify settings, and test infrastructure changes. They define the blast radius by enforcing non-human / system / service permissions, access controls, automated policy checks, and cloud cost guardrails to ensure delivery remains secure, reliable, and cost-effective.
Freed from the burden of manually maintaining pipelines and troubleshooting infrastructure inconsistencies, DevOps Engineers can focus on designing the systems that allow software to be delivered safely at scale. Rather than deploying changes one at a time, they build the operational frameworks that enable humans and autonomous agents to continuously deliver software within well-defined boundaries.
Their attention shifts upward toward the health of the entire ecosystem: designing resilient cloud architectures, evolving organizational guardrails, and optimizing how people and machines work together. They are empowered to Validate that operational controls are functioning as intended, Understand the complex interactions occurring across distributed environments, and Lead the enterprise's long-term platform strategy. Their role evolves from maintaining delivery pipelines to stewarding the autonomous systems that power them.
The Production Data Analyst: Automated Lifecycle Self-Healing
Production Data Analysts, who do the painstaking work of playing digital detective whenever an application slows down or user conversion drops, will also see big changes in the Builder Age. Their world will shift from endless data excavation to directing real-time system diagnostics. Today, Data Analysts, including Security Analysts, spend massive amounts of energy pulling logs, writing queries, and trying to tie disconnected data points together to find anomalies in performance and activity. But when software updates are deploying continuously, human analysts can't spend hours building diagnostic timelines after the fact. Instead of hunting through messy, disjointed audit logs to find out what broke three hours ago, Analysts use AI monitoring agents to track live user behavior and system telemetry simultaneously, turning the role from a backward-looking investigator into a proactive protector of the system’s quality.
The Operational Shift:
The Existing World: When an unexpected system performance drop, security anomaly, or user experience issue occurs, the Data Analyst manually runs query scripts across disjointed audit log databases. They spend hours sifting through millions of lines of user interaction data, system performance metrics, and security logs to piece together a timeline and pinpoint the root cause. They are stuck in a slow, reactive cycle, spending their time extracting raw data and building incident reports while business stakeholders wait for answers.
The Emerging World: The Analyst manages a self-diagnosing production environment. They direct specialized AI agents to continually monitor live telemetry streams across key domains of quality: user behaviors (like session replays), performance metrics, and security configurations. Within seconds of an anomaly detection, the agentic framework automatically executes a precise sequence:
With Data Analysts being relieved of highly manual tasks like data retrieval and raw log extraction, they can scale their impact across the entire product lifecycle. Instead of spending their days reacting to production fires after the business has already taken a hit, they focus on optimizing the active health of the platform and ensuring user workflows remain entirely seamless. Through their efforts, production anomalies are surfaced quickly, with a complete diagnostic and impact analysis ready to hand off to the responsible party.
They make a welcome shift from forensic data mining to driving proactive product health and user satisfaction. With the support of their AI monitoring agents, they can Validate that live system behaviors match business goals, Understand how real users navigate new features under live conditions, and Envision the data-driven optimization strategies that move the company forward.
The AppSec Architect: Engineering Trust At Scale
Application Security has always been a cross-functional discipline. While its mission is often described as preventing vulnerabilities, its true responsibility is much broader: enabling organizations to build software safely without impacting overall innovation. As AI dramatically accelerates software creation, this responsibility becomes even more important. The challenge was never that developers didn’t care to or could not learn to write secure code; it was that security teams could not manually scale their expertise fast enough to influence the decisions made across an expanding software ecosystem.
The Existing World: The AppSec Architect spends much of their time understanding and connecting the people, processes, and technology across the organization. They review production risks, operate security tooling, conduct threat modeling exercises, manage vulnerability backlogs, and partner with development teams to prioritize remediation efforts. They build relationships with Product, Engineering, DevOps, Enterprise Architecture, and Security Champions to proactively influence the quality of the software designed. Yet, despite these efforts, they are often forced into a reactive posture, discovering issues after implementation and relying solely on interpersonal influence rather than engineering to drive adoption.
The Emerging World: The discipline evolves from chasing vulnerabilities to engineering systems of prevention. Instead of attempting to manually review a critical mass of code and system design outputs, AppSec Architects codify their expertise into intelligent guardrails embedded directly within the software delivery ecosystem. Security policies, architectural patterns, encryption requirements, and compliance standards become active participants in the development process. AI agents continuously validate decisions, identify risky patterns, and suggest secure alternatives long before software reaches production, then continuously monitor and block production anomalies.
Freed from endless triage, AppSec Architects invest more deeply in the uniquely human work that scales security across the enterprise. They strengthen Security Champion programs, facilitate threat modeling exercises, improve developer experiences, refine organizational standards, and create feedback loops between production telemetry and prevention activities. They focus less on individual vulnerabilities and more on understanding why vulnerabilities emerge in the first place.
Perhaps most importantly, they become stewards of trust across both human and machine systems. They are responsible for defending not only the applications being built, but the AI development workflows building them. They threat model autonomous pipelines, establish boundaries for agent behavior, and ensure that humans remain accountable for security decisions that machines can only infer.
Their focus shifts upward and outward: continuously Validating that controls remain effective, Understanding the evolving attack surface created by both humans and autonomous agents, and Leading the enterprise toward a secure-by-design future. Their role evolves from finding vulnerabilities to engineering the systems that prevent them.
Conclusion: The Horizon of the Agentic Process
The Builder Age isn’t about replacing human talent; it’s about shifting human effort from manual execution to strategic direction. By automating the high-volume, repetitive mechanics of software development, teams are finally freed to focus on system integrity, security resilience, efficiency, and user experience. The technical friction of software building is receding, but the need for rigorous engineering discipline and sharp product vision has never been greater.
True operational success in this new era requires far more than simply buying the latest AI tools. It demands a fundamentally rewritten operating model, new team dynamics, and must-have quality frameworks. Ultimately, business value will not be measured by how many thousands of lines of code an AI agent squad can generate in a minute. It will be determined by how effectively humans direct those squads, establish the governance boundaries, and maintain absolute ownership and accountability over the results.
What’s Next?
In our next article, we will go deep into the operational mechanics of this new reality, applying these role definitions to the emerging Agentic SDLC. We will provide a practical blueprint of our future delivery flow, mapping out exactly who is responsible for what at each phase, and outlining how companies can execute a safe, disciplined transition to an automated pipeline without compromising security or software quality.
Comments