How AI is improving developer experience

Artificial intelligence is transforming what it means to be a software developer. Along the way, it’s reshaping developer experience too.

According to a report on the impact of generative AI in software development from Google Cloud’s DORA team, developers who extensively use generative AI in their work experienced higher developer satisfaction and increased developer productivity. A longitudinal study on the impact of AI coding assistants on software engineering from researchers at the University of Auckland in New Zealand uncovered similar results, with 84% of survey participants reporting better productivity.

However, the study also found that in a span of six months, two of the three core dimensions of DevEx declined. While feedback loops (how quickly developers learn if something works) improved, both cognitive load (the mental effort it takes to complete tasks) and flow state (a state of deep, focused work without distractions or interruptions) worsened.

The authors attribute this erosion to reallocating time and effort from writing code to verifying it. They classify this as “supervisory engineering work,” a new activity within the software development lifecycle (SDLC) that encompasses directing AI, evaluating its outputs and correcting its errors. “AI coding assistants are impacting both the nature of software engineering work and how engineers experience it,” wrote the researchers in their study.

So how is AI actually affecting developer experience? We spoke with a few IBM developers to get the scoop on how AI makes for better DevEx, where it’s still falling short and their tips for using AI to improve developer experience.

For Rosemary Wang, a developer advocate at IBM focused on infrastructure as code (IaC), AI streamlines information gathering by “making the unknown known and capturing [information] in a way that someone else can get that knowledge.”

Debugging across multiple layers in a software stack, for example, can be distilled into a single prompt fed to an AI agent. This coding agent might feature an MCP server that facilitates communication with a debugger or treats debugging as a series of tool calls: set breakpoints, step through code, inspect variables and evaluate expressions to diagnose logic flaws. And with AI-powered IDEs like those offered by Cursor and IBM Bob, software engineers can spend less time context switching and more time in a flow state.

“They can move forward without necessarily having to stop and search for any answer manually,” says IBM AI engineer Prachi Modi. “I like to think of AI as a guide to a large and complicated system.”

Generative AI coding tools also automate necessary yet repetitive tasks, including writing boilerplate code, code documentation, scripts for CI/CD pipelines and unit tests. This helps reduce cognitive load, freeing up developers to tackle more critical issues or creative work.

“AI gives me ways to speed up work that used to take weeks—now it’s taken sometimes minutes or days,” says Kaoutar El Maghraoui, a principal research scientist at IBM Research. “The setup work stopped being the expensive part to spend a lot of time on. We are now leaning more into the hardest problems.”

When it comes to junior developers or new members of a software engineering team, AI can make way for smoother onboarding and upskilling. For instance, El Maghraoui forms part of a team building the software ecosystem for IBM’s Spyre AI accelerator. She notes that new members coming in will need to grasp the inner workings of various components and their dependencies before they can safely change a single line of code. But employing AI coding assistants like ChatGPT and GitHub Copilot for code explanation or code summarization helps shorten the learning curve.

“That work of understanding the existing software stack and the complexity of it used to take two weeks. Now, they’re doing useful work in two days,” she says.

Despite its benefits, AI still falls short in some areas. Accuracy is a primary one. AI tools can suggest code completions or generate code snippets that look exactly right on the surface but might end up being wrong in a way that’s difficult to perceive at first glance.

“AI is really good at helping but not so good at being responsible,” says El Maghraoui. “It can write the code, but it cannot answer for whether the code is correct.”

She believes this happens in part because code LLMs haven’t been trained to express uncertainty. “The model will not tell you what it does not know. It just tries to hallucinate. It writes something that looks plausible, which can be misleading,” El Maghraoui says.

Context awareness is another limitation. While code assistants typically suggest changes that work, some of these changes might not fit other parts of the system or go against a company’s application development standards.

“AI does not always understand why something was built in a certain way,” says Modi. “It may understand individual pieces of a puzzle without always seeing the full picture.”

For instance, an AI tool might recommend refactoring a particularly complex section of code without considering the decisions that led to that complexity. Meanwhile, a software developer knows the code exists because of a customer need or security requirement.

“A lot of why code looks the way it does is not in the code at all. It is in the design review, in the postmortem analysis, in an argument somebody had and never wrote down. If I use a model to read the repository code, it sees the decisions, but it’s not seeing the reason behind it,” El Maghraoui says.

And with AI rapidly producing more code than ever, software engineering teams are trying to keep up. The bottleneck has shifted to the code review step of developer workflows: assessing AI-generated code and pull requests for security vulnerabilities, evaluating performance, validating code quality and verifying correctness.

To make the most of AI for improving developer experience, Wang advises limiting its scope and starting small, creating much more control within the process. “We’re introducing a huge amount of review fatigue by encouraging AI to generate such a large amount of code,” she says. “We’ve forgotten the point of software discipline, which is to scope your work and put acceptance criteria around it.”

Providing as much high-quality, relevant context as possible goes a long way. This can be in the form of coding conventions, design documents and examples of best practices, among other best practices. “AI is more effective when it builds an understanding of the environment it’s working on,” says Modi.

El Maghraoui echoes the sentiment: “Somebody who curates a good context very well can get even more from a weaker model than somebody who does not get that context right—even if they use the best model out there.”

She also proposes prompting AI code assistants for tests before instructing them to generate code, making sure these tests encompass edge cases, failure modes, invalid inputs and race conditions. “AI is better at breaking code than writing it, and this is the cheapest way I know to cut down the checking time later,” says El Maghraoui.

Wang cautions, however, that setting up these harnesses for AI coding tools to generate more accurate responses can be time-consuming. “Years back when people were talking about infrastructure automation, there was this idea of the ‘automation fear cycle.’ You would spend a lot of time trying to automate something and it would go horribly awry, then it takes everything down and you don’t know what to do after that,” she says. “I think we have the same problem right now. How do you justify a high-effort investment in the short term for a long-term gain? It’s very challenging to identify that balance.”

This makes human judgment even more valuable, and that judgment can be strengthened by thoroughly understanding software development fundamentals, such as algorithms, architecture, compilers and operating systems. “AI helps me most where I know least and least where I know most,” says El Maghraoui. “Understanding whether what AI gives us is solid code that also meets requirements, performance aspects and good design is a very important piece that we don’t want to overlook and just delegate to AI.”

For Modi, this means treating AI as a collaborator and not the final decision-maker. “AI is very useful for helping developers think and explore ideas, but it should not be making decisions for them. Developers should maintain ownership of whatever they build.”

She adds that developer productivity must not come at the cost of privacy or security. “Developers should never share confidential code or customer information. Responsible use is equally important, so be responsible with AI.”

In terms of measuring developer experience, metrics from DORA and the SPACE framework remain key, but El Maghraoui suggests moving beyond speed and activity to outcomes. “What I really care about is how much of my day goes into things that are not the actual problem I’m trying to solve, and whether I feel sure about the code when I merge it,” she says. “I would look at how long it takes a new person to make a meaningful commit, how much of the day goes into review, how confident engineers are saying they feel about what they’re committing and how much that code turns into impactful features and capabilities that are really making a difference.”

The end goal, after all, “is not simply to generate more code for developers or to complete tasks faster,” says Modi, “but to help developers make better decisions, build more reliable software and spend more time solving more meaningful problems.”