Anand Naidu is a veteran of the software engineering world who has navigated the industry’s shift from manual, syntax-heavy development to the current era of agentic orchestration. As a resident expert proficient in both frontend and backend systems, he has spent years dissecting the intricacies of various coding languages and their practical applications in enterprise environments. Now, in 2026, he stands at the forefront of the artificial intelligence revolution, helping organizations move beyond the initial hype of generative tools to build robust, production-grade systems. His deep technical insights provide a crucial bridge between the raw power of large language models and the stringent requirements of high-stakes industries like financial services and global logistics.
The following discussion explores the profound transformation occurring within the software development lifecycle, where productivity gains are being weighed against the necessity for human accountability. We examine how the “shift left” philosophy has evolved into outcome-based design, the economic realities of managing token consumption, and the critical role of governance in preventing codebase fragmentation. The conversation also highlights the changing profile of the modern developer, moving away from simple code execution toward a role defined by orchestration, architectural oversight, and the management of hybrid human-agent teams.
AI tools are increasingly handling routine tasks like code scaffolding and test generation. How are teams now navigating the shift from manual labor to higher-level architectural oversight, and what does this transition look like on the ground?
The shift we are seeing in 2026 is nothing short of a fundamental redefinition of what it means to “write” software. In the past, a developer might spend hours or even days on the repetitive plumbing of a project—things like setting up code scaffolding, writing boilerplate documentation, or generating basic test cases. Today, those “less-engaging” tasks are largely handled by AI, allowing our teams to spend significantly more time on the high-value activities that actually drive business value, such as solution design and complex architectural decision-making. We are seeing a massive “shift left” in the development cycle, where the focus has moved toward outcome-based design rather than just getting the syntax right. At organizations like Nets, for example, developers are using AI to refine user specifications and accelerate troubleshooting, which has fundamentally changed the daily routine. The data backs this up remarkably well; currently, about 55% of developers in the Asian market report saving at least seven hours every single week by leveraging these tools. This is a staggering jump from just 18% who could claim such savings only a year ago. On the ground, this looks like a developer spending their morning reviewing AI-generated test scenarios and their afternoon debating the resilience of a new microservices architecture, rather than being buried in a debugger all day.
While productivity is skyrocketing, there are still significant reservations about letting AI handle high-risk, complex workflows independently. Can you elaborate on why human judgment remains non-negotiable in environments like financial services or regulated payments?
The reality is that while AI is an incredible co-pilot, it still struggles with the complex reasoning and deep business context required for high-stakes enterprise processes. When you are dealing with a payments operator that has been a cornerstone of the financial system since 1985, you cannot afford the luxury of “hallucinations” or opaque decision-making. In a highly regulated environment, every critical decision must be transparent, auditable, and accountable. Currently, about 79% of developers still cite hallucinations or incorrect outputs as their top concern, and that is why we see a massive 86% of engineers still validating AI-generated outputs nearly every single time. Specifically, in areas like Anti-Money Laundering (AML) or Know Your Customer (KYC) protocols, the industry still faces massive challenges regarding governance and customer consent. AI models are maturing, but they aren’t yet at a stage where they can independently orchestrate end-to-end decision-making across diverse stakeholders like risk, compliance, and legal partners. There is an emotional weight to this as well—developers are generally open to giving AI autonomy for reversible, low-risk work like documentation, but as soon as a task moves closer to the production environment, the desire for human oversight becomes absolute. Only about 38% of teams currently feel their codebase is even ready for a fully autonomous agent.
We’ve seen the rise and fall of “tokenmaxxing” as organizations realize that AI costs can spiral out of control. How are technical leaders currently managing the economic side of AI to ensure that the cost of model calls doesn’t exceed the value being created?
The era of “tokenmaxxing”—where employees were encouraged to consume as many tokens as possible just to experiment—ended very abruptly when IT departments started seeing their annual budgets vanish in a matter of months. In 2026, the focus has shifted toward what we call “harness engineering” and strict engineering hygiene. It is no longer enough to just throw the biggest, most expensive model at every problem. If a developer is just looking for basic code refactoring, they shouldn’t be using a massive, high-parameter model that burns through credits needlessly. We are advising teams to implement deterministic rules and strict “harnesses” around agentic workflows to ensure they are focusing on specific business outcomes. For instance, if you only measure the volume of code lines being generated, your AI agents will happily burn through tokens to produce a mountain of code that may not even be necessary. Instead, we are now measuring the “time-to-value”—how long it takes a feature to go from an idea into a customer’s hands. This shift in measurement forces developers to be thoughtful about context; failing to provide the right context to an AI agent actually results in higher token consumption because the agent has to “guess” more, which leads to hallucinations and wasted cycles. It’s about building a scaffolding that validates what the agent is doing before it ever hits a production environment.
With the prediction that agent-assisted software engineering will reach 90% by mid-2027, the role of the developer is clearly evolving. What specific new skills or mindsets must an engineer adopt to thrive as an “agent architect” rather than a traditional coder?
The myth that we won’t need developers anymore is being thoroughly debunked by the reality of the work we’re doing today. What we actually need are better developers—individuals who can act as orchestrators and architects of these hybrid human-agent teams. For example, at SAP, roughly 30% to 40% of the development cycle is now AI-assisted, using sophisticated agentic tools like Claude Code. This requires a developer to be an expert in “specs-driven development.” You have to know how to construct specifications so clearly that an agent can understand the intent, the boundary exceptions, and the expected behavior in a fail-state. It is less about typing out the logic and more about defining the “intent” and the “guardrails.” Interestingly, we still require our engineers to know basic coding because you cannot effectively review or optimize AI-generated code if you don’t understand the underlying logic. At SAP Labs, new engineers now go through a rigorous two-month training program specifically focused on AI ethics and the governance model. They have to move beyond just generating code and start thinking about sustainability, security, and the integration of these tools into the broader ecosystem. The role is becoming much more about being a reliability engineer and a solution architect who ensures that the AI stays within the data boundaries and authentication protocols that keep the enterprise safe.
Governance and standardization seem to be the primary barriers to wider AI adoption within large organizations. How can companies prevent “fragmentation” where different teams are using different, unvetted AI tools?
Fragmentation is a silent killer for enterprise security and operational resilience. If Team A is using one AI model and Team B is using another without a shared governance framework, you end up with inconsistent standards, security vulnerabilities, and a nightmare for auditability. To combat this, organizations like Nets have established dedicated governance committees and common DevSecOps platforms. This ensures that every tool being used is approved and every use case is vetted for risk. The challenge in 2026 isn’t just a technical one; it’s an organizational one. You need clear accountability for every piece of code that the AI generates. This means setting up oversight mechanisms that are reviewed constantly to keep pace with the market. Without these guardrails, you risk creating a “black box” environment where no one truly knows how a certain piece of software reached its conclusion. By standardizing the tooling and the governance models, you ensure that as the AI market changes, the organization can pivot without having to rebuild its entire security posture from scratch. It’s about creating a “safety net” that allows for innovation while maintaining the operational risk management that a highly regulated sector demands.
What is your forecast for the future of the developer-agent partnership over the next year?
I believe that by mid-2027, the traditional “solo coder” will be a relic of the past, as we move toward a baseline where 90% of engineering is agent-assisted. However, the most successful organizations won’t be the ones that simply generate code five times faster; they will be the ones that transform their entire delivery chain to match that speed. We are entering an era where the bottleneck won’t be the writing of the code, but the ability of business teams to generate demand and operations teams to deploy and scale those solutions at the same pace. Developers will increasingly transition into “Platform Engineers” and “Reliability Specialists,” spending the bulk of their time ensuring that the complex, interconnected web of AI agents is operating securely and efficiently. We will see a much deeper integration of AI in the early and middle phases of the lifecycle—specifically in testing and knowledge management—where the returns are already proving to be the highest. The real value won’t be in the model call itself, but in the human judgment that builds the safeguards and ensures the technology remains trustworthy in a production environment. The foundation of software engineering has shifted, and those who embrace the role of the “Agent Architect” will be the ones leading the charge into this new era of enterprise transformation.
