From code writer to creative director
Four years into widespread AI adoption in software development, a clearer picture is emerging of how the role of the developer is changing. The most advanced AI users describe their work less as producing code and more as orchestrating and verifying it. Recent interviews with developers who have pushed deepest into AI workflows reveal a consistent pattern: the core activity has shifted from implementation to setting direction, guiding agents, and validating output.
This marks a significant departure from where things stood just two years ago.
The 2023 baseline: hesitation and identity
In 2023, interviews with developers found them open to AI assistance for specific tasks—summaries, explanations, and suggested plans of action—but resistant to ceding implementation or decision-making to the technology. At the time, developers viewed AI as unreliable for large implementations. But there was more to it than technical limitations: implementation was central to their professional identity.
One developer captured this tension with a direct question: "If I'm not writing the code, what am I doing?"
That question became increasingly pressing as projections emerged about AI writing the vast majority of code. Without a clear answer to what developers would do instead, meaningful AI adoption faced a fundamental obstacle.
The 2025 picture: fluency through practice
Interviews conducted this year focused on advanced AI users—developers who have documented sophisticated agentic workflows and express optimism about delegating work to AI. Their path to proficiency was not smooth or intuitive. Most described relentless trial-and-error and a deliberate commitment to using AI tools daily for everything, even when the tools felt clumsy or unreliable.
This persistence eventually produced informed judgment about when to work synchronously with an agent, when to run agents in parallel, and when to prompt an AI tool to ask clarifying questions. The typical progression moved from skepticism through exploration to collaboration and finally to strategic use. Along the way, developers developed clearer expectations about speed, iteration, and accuracy appropriate to each stage.
None of these strategists started out that way—most began as skeptics or cautious explorers. Their advancement tracked not just personal growth but also the evolution of tools they were willing to adopt: completions first, then chat and copy-paste workflows, then AI-enabled IDEs, and finally multi-agent setups. What appears from outside as adoption of new features was, from the inside, a gradual expansion of what developers felt comfortable delegating.
Reinvention, not loss
At the most advanced stage, developers describe development sessions that look fundamentally different from the autocomplete era. Less time goes into writing code in the traditional sense; more goes into defining intent, guiding agents, resolving ambiguity, and confirming correctness. Delegation and verification become the primary activities.
This transition directly answers the 2023 question. Developers who once worried about losing their role now describe setting direction, constraints, architecture, and standards. The phrase that emerged from interviews—shifting from code producers to creative directors of code—captures the change. Notably, those who reach this level describe it not as a loss of craft but as a reinvention of it.
The shift is hard to understand without experiencing it. Developers report that their sentiment toward the future changed only after witnessing the transformation in their own work. What initially felt like an existential threat became a strategic advantage as they gained confidence and agency with AI tools.
The visible signals of change
While interviews capture early adopters, ecosystem data suggests these practices are spreading. The 2025 Octoverse report showed TypeScript becoming the #1 programming language by monthly contributors on GitHub in August 2025. This rise reflects a strategic alignment with AI workflows: TypeScript's explicit type system and structural clarity help both developers and AI reason about correctness. When AI generates large portions of code, languages that enforce structure and surface errors early become a safer choice for delegation.
Other data points reinforce the trend. 80% of new developers on GitHub in 2025 used Copilot within their first week, suggesting AI exposure now begins at the very start of a developer's journey. Early contact may lead to earlier confidence and faster progression through stages of AI maturity.
Additionally, within five months of releasing its coding agent—which can autonomously generate pull requests—developers used it to merge more than 1 million pull requests. Each merge represents a cycle of delegation and verification: imagining a change, articulating intent, breaking down tasks, providing context, and validating the results.
Skills for the new role
As implementation moves into the background, the skills that matter shift toward three layers of responsibility: understanding the work, directing the work, and verifying the work. Developers across interviews consistently identified strengths in all three as essential to working confidently with AI.
AI fluency
Developers need an intuitive sense of how AI systems behave—what they handle well, where they fail, how much context they require, and how to adapt as capabilities evolve. This understanding comes from repeated use and experimentation. Fluent developers learn to assemble their own AI stack: choosing tools and features for different projects or running multiple configurations in parallel for end-to-end workflows.
Fundamentals
Deep technical knowledge remains essential even as AI takes on more implementation. Understanding algorithms, data structures, and system behavior lets developers evaluate complex output, identify subtle issues, and judge whether an AI-generated solution is actually sound.
Product understanding
Developers increasingly operate at the level of outcomes and systems rather than snippets. This means understanding user needs, defining requirements with clarity, and reasoning about how a change affects the overall product. Framing work in terms of outcomes ensures that what gets delegated to AI aligns with the real goals of the feature or system.
Directing the Work
With the groundwork of AI fluency in place, developers turn to a second cluster of skills: guiding AI tools, systems, and agents so work progresses both efficiently and safely.
Delegation and agent orchestration
Delegating successfully starts before the agent does anything. Developers must frame the problem clearly, break it into meaningful units of work, supply the right context, state constraints, and define what success looks like. More experienced developers also weigh when to hand off a task. Some interactions are best handled synchronously, with the developer working alongside the agent, while others can be dispatched to run independently in the background. The communication itself—precise, thorough, and structured—is what turns this from a one-off trick into a repeatable, reliable workflow.
Developer–AI Collaboration
When collaborating with an agent in real time, productive sessions run on tight iterative loops. Developers set stopping points, deliver corrective feedback, ask the agent to critique its own output, or prompt it to surface clarifying questions before proceeding. Several interview subjects described a far more proactive approach to building shared understanding: instructing the agent to "interview" them first, so that the agent gathers the full context it needs before generating any code at all.
Architecture and Systems Design
As AI absorbs more of the low-level code generation, the developer's attention moves upward to architecture and system design. This means defining the scaffolding around the code itself: setting system boundaries, documenting patterns and data flow, and specifying how components will interact. A clear architectural foundation does double duty: It gives agents a safer, more constrained environment to work in, and it makes integrating their outputs into the broader system more reliable.
Verifying the Work
The second major pillar of the new developer identity centers on the final gate: ensuring that output is correct and high quality. In interviews, developers described this as a defining feature of their work in the AI era, not a peripheral task.
Verification and Quality Control
AI-generated output demands rigorous scrutiny. Verification takes multiple forms, including code reviews, test suites, security checks, and constantly re-examining the assumptions baked into the code. Many participants reported dedicating more time to verifying work than to generating it—and said they felt this distribution of effort was exactly right. Strong verification habits are the enabling condition for scaling up delegation; they are what allow developers to loosen the reins and trust agents with increasingly substantial chunks of work.
Crucially, verification has also changed its position in the workflow. It used to be a discrete, final step in the process—something you did at the end. With AI-supported workflows, it has become a continuous, ongoing practice. This shift is a direct consequence of the Annie Vella, a Distinguished Engineer at Westpac NZ, recently wrote an exceptional post about how the software engineer role changes with AI and the new competency map for engineers building systems with LLMs and agents. Annie’s experience (and research) share many similarities with the findings from our interviews with advanced AI users. A worthy read!
Where Things Stand This Year
The impression that emerges from the interviews is a workforce that has turned initial curiosity into concrete preparedness. Developers see their profession transforming in real time, and they expect the pace of change to remain high. Their response has been to build AI fluency, practice confident tool and agent orchestration, and treat delegation and verification as core components of the craft. The developers interviewed view these capabilities as a distinct competitive advantage—one they expect to define the next era of software development.
The broader value a developer brings is shifting away from the mechanics of writing code and toward judgment, architecture, reasoning, and taking responsibility for outcomes. In essence, the work is moving up the ladder of abstraction. For those building tools and measuring AI's effect on productivity, keeping perspective aligned with that evolution is essential.
Tracking the Evolving Landscape
For anyone seeking to measure these shifts, there is no single source of truth. However, several kinds of data provide a healthy signal:
- Large-scale data reports—such as GitHub's Octoverse report—surface macro-level adoption and behavioral patterns.
- Longitudinal industry studies, like DORA, help show where productivity gains stall or compound over time.
- Field research and developer interviews are essential for interpreting the meaning of big data, and for catching emerging trends before they show up at scale.
- Open source activity tends to reveal which workflows developers will adopt first—often ahead of enterprise uptake. A useful public data source for tracking this is the GitHub Innovation Graph, which is updated quarterly.
Methodology: Who Was Interviewed
This set of findings draws from a fresh round of interviews with 22 full-time software engineers based in the US. Participants were recruited via the Respondent.io platform, and there was no requirement that they be GitHub users. Selection was based on a screening survey that assessed the depth and breadth of each candidate's AI usage. To qualify, participants had to meet three criteria: use AI for more than half of their coding work, work with at least four AI tools from a pre-defined list of thirteen, and demonstrate experience with the full range of advanced AI-assisted development activities covered in the survey.
Interview subjects came from a range of organizational contexts: 55% worked in large or extra-large enterprises, 41% in small- or medium-sized enterprises, and 4% in startups. Professional experience also spanned a wide spectrum, with 14% having 0–5 years, 41% having 6–10 years, 27% having 11–15 years, and 18% having over 16 years of experience.
