JA

The empathy software engineers need in the age of AI

Here is what this post covers:

Introduction

Software engineers spend their days thinking about development efficiency, network transfer efficiency, API speed, and the state of the system. That means they spend a lot of time facing systems, while the share of their time spent interacting with people tends to be smaller than in other professions.

Because of this, non-engineers sometimes see engineers as cold or hard to approach.

This post looks at how the need for empathy in software engineering changed before and after the age of AI.

By empathy, I mean the ability to put yourself in someone else’s position and imagine what they are struggling with and what they want. Psychology often separates “affective empathy” (feeling what another person feels) from “cognitive empathy” (understanding another person’s thoughts and situation). This post is mostly about the second kind. What an engineer’s work needs is less about sharing someone’s feelings and more about picturing their situation accurately.

Empathy before the age of AI

The users behind the system

Even before AI became common, an engineer’s job was never only about the system. Software is built for someone to use.

When requirements are being decided, users and customers cannot always put their problem into words accurately. For example, behind a request like “please add one button to this screen” there may be a real problem like “the month-end totals take two hours every time.” If you add the button as asked and the totals still take two hours, nobody will use it. The value of what you build depends on whether you can imagine the person’s work and situation, not only the words of the request.

People read the code too

In team development, the person who reads your code is also a person. PEP 8, the Python style guide, introduces Guido van Rossum’s view that code is read much more often than it is written. Variable names, how you split functions, commit messages, and pull request descriptions all exist so that the next reader does not get lost. Writing readable code is an exercise in imagining the reader’s position.

How team members relate to each other also affects results. In an internal study called Project Aristotle, Google found five factors shared by effective teams and ranked psychological safety as the most important. Psychological safety is the feeling that you can admit a mistake, ask a question, or suggest a new idea without being embarrassed or blamed. Everyday behavior builds it: not dismissing someone’s code in a review, and answering questions politely.

Room to be valued for technical skill alone

Even so, before AI there were engineers who were valued for technical skill despite weak empathy.

One reason is that being able to write code was itself scarce. Someone who could implement a complex feature correctly and quickly was valuable for that alone. Another reason is the division of labor. Project managers and people in upstream roles handled negotiations with customers and organizing requirements, so the people implementing could focus on turning a fixed specification into code. Users’ voices reached them only after someone in between had turned them into a specification.

So before AI, empathy was needed in every role, but it was easy to treat it as a nice-to-have that technical skill could make up for.

Empathy in the age of AI

The falling cost of writing code

AI coding assistants have already become an ordinary tool. In Google’s DORA report from 2025, 90% of respondents said they use AI at work. If the specification is clear, you can have AI write a large amount of code in a short time.

When the cost of writing code falls, the center of the work moves from “how to build it” to “what to build.” Being able to build fast also means being able to build the wrong thing fast. The ability to see what users really need matters more because implementation got faster.

DORA’s research also shows how much it matters to look at users. The 2023 report found that teams that focus on the user have 40% higher organizational performance than teams that don’t. The 2025 report then names a user-centric focus as a prerequisite for getting value from AI. It explains that AI is most useful when it is pointed at a clear problem, and that interest in users provides that direction.

The context you give AI, and understanding people

When you ask AI to do a job, you have to put the purpose and constraints into words. Who will use this feature, and in what situation? What comes first, and what can be given up? This context is often not written in the code or the documents. It lives in the heads of people who have talked with users and teammates.

AI does not know these unstated assumptions. If a person who cannot picture the user’s situation makes the request, the AI returns something that sounds plausible but misses the point. A person who understands the other party’s problem concretely can give AI precise instructions. How well you use AI depends on how well you write instructions, and also on how well you understand people before that step.

Reviews and verification still need a human eye

As the amount of AI-written code grows, so does the work of reading and checking it. In DORA’s 2025 report, 30% of respondents said they have little or no trust in code generated by AI. Someone still has to check AI output in the end.

Empathy matters here as well. If you turn a huge AI-written diff into a pull request as it is, the burden on the reviewer gets heavy. Split the change into small pieces, explain in the description why the change is needed, and make sure you understand the parts the AI wrote. Without this kind of consideration, only the review burden grows on the team.

Verification also takes more than passing tests. AI can write code that meets the specification, but it will not judge whether the person using the screen gets confused, or whether someone who sees an error message knows what to do next. Checking from the user’s position is a role that stays with people.

Agreement and responsibility stay with people

Finding middle ground among stakeholders with conflicting interests. Explaining a technical risk in words that non-engineers understand. Telling the affected people what is going on when an incident happens. AI can help draft the wording of such messages, but it cannot take over the trust you have with the other person or the responsibility for the outcome.

DORA’s 2025 report sums it up this way: AI does not fix a team, it amplifies what is already there. Strong teams get better with AI, and teams with problems see those problems stand out more. If you bring AI into a team where people do not get along, it only makes that weakness bigger.

What changed before and after AI

Here is how the points above compare before and after the age of AI.

AspectBefore AIAge of AI
Place of empathyA nice-to-have that technical skill could make up forA core skill that technical skill can hardly make up for
Engineer's valueImplementing correctly and quicklyWorking out what should be built
Distance from usersSomeone in between turned users' voices into a specification and passed it onOne person can handle everything from requirements to implementation, so engineers face users directly more often
Where empathy is usedListening to requirements, readable code, reviewsAll of the left, plus instructions to AI, checking AI output, and writing diffs that are easy to review
Effect of lacking empathyHard to notice if implementation skill is strongLeads to building the wrong thing, fast and in large amounts

The biggest change is that empathy went from a skill that technical ability could make up for to a skill that technical ability can hardly make up for. More of the implementation can be left to AI, so most of the work left to engineers now assumes an understanding of people.

Another change is the distance between engineers and users. With AI, one person can more easily handle everything from organizing requirements to implementation. As a result, there are more situations where nobody sits in between to turn users’ voices into a specification, and engineers have to face users themselves.

Some things have not changed. Software is still built for people. Empathy was needed before AI too, but strong implementation skill hid it. It is closer to the truth to say that once AI took over implementation, a skill that was always needed became visible.

Wrapping up

Software engineering is a job with a lot of time facing systems. Even before AI, though, engineers needed empathy when they picked up on users’ problems and when they wrote code that teammates could read. At that time, being able to implement was valuable in itself, and the division of labor let engineers keep their distance from users. So empathy tended to be treated as something technical skill could make up for.

Now that AI writes code, the cost of implementation has dropped a lot. As a result, the weight has shifted toward working out what to build, giving AI the right context, checking AI output from the user’s position, and building agreement with stakeholders. None of these works without the ability to imagine another person’s situation.

The empathy engineers need in the age of AI is not a new skill. It was always needed, but strong implementation skill kept it out of sight. Whether you can imagine the people on the other side of the system will largely decide an engineer’s value from here on. That is what I believe.

References