A vital shift is underway in software development, one that redefines how we build, but also who we are as developers. In recent interviews we spoke with 22 developers that already use AI tools heavily in their workflow, and learned how they got there, how their craft has changed, and where they see things going.
A transformation in the making
For these developers at the forefront, making AI a core part of their work is not a distant, long-horizon future, but a change that is happening today. For many, the initial encounter with AI tools was met with a healthy dose of skepticism. “Pretty cool, but gimmicky” was a common refrain, which now developers interpret as high initial expectations clashing with the jagged frontier of AI’s unpredictable capabilities. That’s a point where many write off AI tools as unhelpful, but those who continue experimenting reach pivotal “aha! moments” of both time savings and figuring out tool capabilities and how to match them to their work.
The developers who found success with AI tools have a strong underlying motivation to prepare for what they anticipate will be an overhaul of their profession. To that end, they relentlessly experiment with various AI tools, even when the tools aren’t consistently helpful. “Either you have to embrace the Al, or you get out of your career” one developer said.
What does embracing AI look like for these developers? We believe it’s a phased evolution, fuelled by daily trial and error:
Stage 1: AI Skeptic. Dabbling with AI in small tasks and questions. Developers are primarily working with code completions and have low tolerance for iteration and errors. If they persevere, they shed their expectations for one-shot success.
Stage 2: AI Explorer. Using AI for debugging, boilerplate and snippets, developers start understanding AI’s limitations. They work with completions and chat, and copy-paste code from browser-based LLMs. With practice, they evolve to brainstorming more complex tasks, embrace iterative prompting, and realize that when getting poor results it’s better to start over, instead of getting diminishing returns from pushing forward.
Stage 3: AI Collaborator. Actively co-creating with AI, and building context engineering intuition. Developers use AI-enabled IDEs for multi-step tasks and multi-file changes and adopt habits like prompting for a plan first, curating agent rules, and strategically switching between tools and between models as they learn AI’s “thought process”. In this stage, developers also join discussions or internal demos to share effective prompts, use cases, and lessons learned.
Stage 4: AI Strategist. Treating AI as a powerful partner for feature development, complex tasks, and large-scale refactorings. Developers build elaborate, multi-agent workflows with planning and coding models, increasing autonomy and parallelism as they go. Developers at this stage are confident and optimistic about the future.
The developers at stage 4 unanimously declare their role has shifted. They now focus on the delegation and the verification of a task. Delegation is about setting up the agents for success with rich context and instructions, designing and refining prompts, reviewing AI’s plans and tradeoffs, and tweaking before proceeding. Verification is all about tearing down the agent’s work – they review and validate that the AI-generated implementation fulfills the objectives and conventions it needs to. These developers moved from writing code to architecting and verifying the implementation work that is carried out by AI agents.
You can probably guess what happened next. When we asked developers about the prospect of AI writing 90% of their code, they replied favorably. Half of them believe a 90% AI-written code scenario is not only feasible but likely within 5 years, while half of them expect it within 2 years. But, crucially, to them this future scenario did not feel like their value or identity is diminished, but that it is reinvented. Having experienced the skill and effort that goes into effectively managing the work of agents, it was now clear to them this will be the value-add activity, rather than leading implementation. “Maybe we become less code producers and more code enablers. My next title might be Creative Director of Code.”, one participant concluded.
Optimism? Realism? Or both?
We tend to see optimism and realism as opposing mindsets. But the developers we heard from had an intriguing blend, they were realistic optimists. They see the shift, they don’t pretend it won’t change their job, but they also believe this is a chance to level up. One developer said “I think of myself as [a] mediocre engineer, and I feel this AI reset is giving me a chance to build skills that will bring me closer to excellence.”
Let’s apply the realistic optimism lens for the rest of this section.
Job outlook
AI is increasingly automating many coding tasks, accelerating software development. As models and tools improve, we see the automation of more complex coding tasks under developers’ orchestration (like the ones we interviewed). This is already reality and no longer a future trend.
If we continue the thought, some traditional coding roles will decrease or significantly evolve as the core focus shifts from writing code to delegating and verifying. At the same time, the U.S. Bureau of Labor Statistics projects that software developer jobs are expected to grow by 18% in the next decade – nearly five times the national average across occupations. They won’t be the same software developer jobs as we know them today, but there is more reason to acknowledge the disruption and lean into adaptation, than there is to despair.
You know what else we noticed in the interviews? Developers rarely mentioned “time saved” as the core benefit of working in this new way with agents. They were all about increasing ambition. We believe that means that we should update how we talk about (and measure) success when using these tools, and we should expect that after the initial efficiency gains our focus will be on raising the ceiling of the work and outcomes we can accomplish, which is a very different way of interpreting tool investments. This helps explain the – perhaps unintuitive at first – observation that many of the developers we interviewed were paying for top-tier subscriptions. When you move from thinking about reducing effort to expanding scope, only the most advanced agentic capabilities will do.
Essential skills, old and new
If we accept that the developer role is transforming, what are the skills that take center stage?
AI fluency: It will be critical to understand the capabilities and constraints of different AI tools, platforms, and models to adjust practices and workflows accordingly. This requires continuous learning-by-doing and a commitment to adaptability, given the “breakneck” speed of AI innovation.
Delegation and agent orchestration: Setting up agents for success will rely on context and prompt engineering, problem framing, breaking down tasks optimally, parallelizing work, and articulating success criteria and constraints. With higher AI fluency, developers will also evolve their judgement and strategies for when to synchronously collaborate with agents or offload tasks to them in the background. Don’t underestimate how critical communication skills are for delegation – it’s not “just” using natural language. Vague or one-liner instructions were never enough to empower human colleagues to successfully hit goals, and they will not work for AI agents either.
Human-AI collaboration: When working synchronously with agents it will be important to have tight iterative feedback loops, set stopping points, instruct for self-critique, as well as encourage agents to ask questions. One of our interviewees prompted their agent to interview them as a way to build context into instructions.
Fundamentals: Understanding and reasoning about code and systems remains critical. Despite AI’s code generation capabilities, developers need a deep understanding of programming basics, algorithms, data structures, and overall software systems. This foundational knowledge enables developers to critically comprehend complicated code, to evaluate the quality of AI’s output and how it got there. It’s critical to the “verification” part of the developers’ role when orchestrating agents.
Verification and quality control: Since AI output requires scrutiny, the ability to rigorously review, test, and verify AI-generated code is paramount. Developers are already practicing this through manual code reviews, running tests, and ensuring adherence to standards. If anything, agentic workflows need an amplified version of this skill, with extended test coverage and thinking about quality and security more upstream.
Product understanding: This is all about systems thinking, meaning looking at the product as a whole. It will push developers to adopt hybrid thinking that combines engineering, design, and product management. Here, defining requirements, prototyping and design, idea exploration, and understanding user needs will be key to make sure that tasks for agents are thought through from an outcome perspective, not just code output.
Architecture and systems design: As AI handles more low-level coding, the importance of understanding overall system architecture, design patterns, and how different components interact becomes elevated. This is crucial for guiding AI and integrating its output effectively.
Implications for education
From a realistic optimism perspective, the rise of AI in software development signals the need for computer science education to be reinvented as well. Educators who adopt this mindset will acknowledge the scale of change while embracing the opportunity to prepare students for a broader, more strategic, and more creative role in shaping the digital world.
Students will rely on AI to write increasingly large portions of code. Teaching in a way that evaluates rote syntax or memorization of APIs is becoming obsolete. Foundational coding remains a critical skill, but now as a way to understand systems, debug AI-generated code, and express ideas clearly to both humans and machines. Instead of “write this loop” we will need to shift to “understand what this code does, and what would break if you changed it.”
LLMs and agents are already writing code in the real world, and ignoring them in the classroom leaves students underprepared. Integrating AI tools into education can enhance learning, by creating more time for deeper design, analysis, and creativity. Curricula must include AI-assisted coding, but focus on how to collaborate with AI: prompting, reviewing, editing, and validating output. In short, teach AI fluency.
Many Computer Science (CS) programs still center around problems that AI can now solve competently. The future belongs to developers who can model systems, anticipate edge cases, and translate ambiguity into structure—skills that AI can’t automate. We need to teach abstraction, decomposition, and specification not just as pre-coding steps, but as the new coding.
The reinvention of the software developer role also opens doors for interdisciplinary thinking and diverse paths into software careers. We can blend CS with design, ethics, systems thinking, and human-computer interaction and encourage students to see themselves not as coders, but as computational creators.
That all influences assessment too. Traditional programming exams no longer reflect real-world skillsets, especially once AI can solve the problem faster than a human. Assessing students on their ability to frame problems, guide AI, critique solutions, and debug complex outputs is more meaningful, and future-proof. We want to create assignments that require AI collaboration: “Here’s what the AI wrote, what’s wrong with it?” or “Improve this spec so an AI can build what you intended.”
Take this with you
The software developer role is set on a path of significant change. Not everyone will want to make the change. Managing agents to achieve outcomes may sound unfulfilling to many, although we argue that’s what developers have been doing on a lower level of abstraction, managing their computers via programming languages to achieve outcomes. Still, as humans we are often reluctant to change, and that’s okay.
Developers worldwide are already moving from skepticism to confidence, reshaping their roles, practices, and mindsets as they partner with AI. For them, what started as fear of AI replacing them is switching to pragmatically embracing the ambitious reality of AI, viewing it as a growth opportunity. As we build the tools of tomorrow we can usher developers through this reinvention of their role in ways that are intuitive, delightful, and cater to developers’ curiosity, keeping them fulfilled and happy during the transition. That makes us optimistic. Realistically. 😉