The Developer's Role in the Age of AI

When we first started coding, learning software development meant understanding things from the ground up.

We learned HTML by understanding tags and how different elements worked together, then learned CSS by building layouts, breaking them, and debugging issues that often came without obvious explanations. A small mistake in JavaScript could lead to hours spent searching Stack Overflow, documentation, forums, and articles, trying to find someone who had already encountered and solved the same problem.

Today, AI coding assistants can generate functions, explain unfamiliar code, create tests, suggest fixes, and help developers navigate complex codebases. Tasks that previously required hours of manual effort can now be completed in minutes.

Early research into AI assisted development is showing measurable improvements in developer productivity. In a workplace study conducted at Microsoft Research, Accenture, and an anonymous Fortune 100 company, 4,867 developers using GitHub Copilot completed 26.08% more tasks per week compared to developers without access to the tool. The study also recorded increases in commits (13.55%) and builds/compilations (38.38%).

A separate controlled experiment by Peng et al. evaluated developers completing a programming task and found that those using GitHub Copilot completed the task 55.8% faster than those without AI assistance.

These studies show that AI provides value by reducing the time required for writing and modifying code. However, responsibility for architecture, security, maintainability, and validating the correctness of the solution still sits with the engineer.

The Role of the Developer Is Moving Up the Stack

Throughout the history of software development, engineers have created abstractions to reduce the complexity of building software. Each abstraction removed the need to manage lower level details while allowing developers to focus on solving higher level problems.

Early developers worked directly with machine instructions and hardware constraints. Programming languages then allowed developers to describe the behavior they wanted from a system without managing machine level instructions directly. Frameworks and libraries further abstracted recurring engineering tasks, allowing developers to focus on application logic rather than rebuilding foundational components.

Each level of abstraction reduced manual effort, but understanding the concepts beneath those abstractions remained essential because developers still needed to make informed decisions, troubleshoot issues, and understand the consequences of their choices.

AI introduces another level of abstraction by reducing the amount of code developers need to manually produce. However, the same principle applies.

Using AI Without Losing Engineering Ability

The risk with AI assisted development is not the use of AI itself, but the loss of the ability to critically evaluate what it produces. The following are key principles that provide a practical foundation for using AI effectively within engineering workflows.

Integrate AI Into the Engineering Workflow, Not Alongside It

AI provides the most value when it is embedded into the existing engineering environment rather than treated as a separate tool used in isolation. Modern coding agents become more effective when they can understand the context around a change by inspecting repositories, analyzing existing patterns, identifying dependencies, running tests, and producing reviewable diffs that fit naturally into existing development workflows.

Integration, however, should not become substitution. Engineers must continue to define the problem, assess design decisions and understand AI-generated changes well enough to explain, maintain and secure them. This avoids “verification debt”, where code is produced faster than it can be properly understood and reviewed.

In order to meet security expectations, AI integration must be matched by controls that reflect the agent’s level of access and ability to act. Each agent should use a dedicated identity, with read-only access by default and write access limited to authorized branches. Agents must not approve their own changes, access unnecessary sensitive code or data, or bypass branch protection. Their actions should remain traceable, while all changes remain small and pass established code review, testing, security scanning and CI/CD checks.

Match the Model to the Task

AI models should be chosen based on the nature of the engineering problem being solved. Smaller, faster models are best suited to clearly defined, low-risk tasks with limited context, such as explaining code, creating simple scripts, updating existing code, generating documentation, and supporting routine development. Larger reasoning models should be used for ambiguous or high-impact problems that require deeper analysis, wider context, or evaluation of competing options, such as architecture design, complex debugging, design trade-offs, cross-document analysis, and large-scale refactoring.

For example, using AI to rename variables across a codebase may only require a fast, efficient model. However, asking AI to evaluate whether a proposed microservices architecture introduces reliability or security issues requires a model capable of deeper reasoning and understanding complex dependencies.

Preserve Human Responsibility at the Right Layer

As AI compresses implementation time, the engineering constraint shifts from producing code to making and validating sound decisions. Engineers must therefore focus on architecture, risk, trade-offs and verification, with human accountability remaining non-negotiable, while automated infrastructure handles repetitive checking.

For example, a developer may ask an AI agent to create a password-reset feature. The generated feature may email the user a reset link and allow them to set a new password successfully, yet leave the link valid indefinitely or allow it to be reused. The feature may work as intended while still introducing security weaknesses. The engineer must therefore anticipate misuse, define the required safeguards and verify that they are correctly implemented.

The developers who will gain the most from AI will not be those who burnt the most tokens, but those who use AI to extend their abilities while continuing to apply engineering judgement, critical thinking, and accountability.