AzamSharp
Why Soft Skills Matter More Than Technical Skills in the Age of AI
Every day I read posts on social media from developers saying they barely write any code themselves. Instead, they rely on AI tools to generate 90% or even 100% of their code. I am not in that group, but I do use AI extensively as part of my development workflow.
As an instructor, I have always taught my students that technical skills are only one part of becoming a successful software developer. This is not the early days of programming when you could lock yourself in a basement and emerge weeks or months later with a completed application.
Software development is much more than typing code. It is understanding the business domain. It is communicating your ideas and intentions to the rest of the team. It is collaborating with product managers, designers, QA engineers, and stakeholders. It is asking the right questions before writing a single line of code. It is making tradeoffs and solving problems. Most importantly, it is making sure you are building the right solution instead of simply writing more code.
As AI continues to improve, writing code becomes less of a competitive advantage because everyone has access to the same tools. The developers who will stand out are not necessarily the ones who can generate the most code. They will be the ones who can communicate clearly, think critically, understand the business, lead discussions, earn trust, and help teams make better decisions.
In this article, I want to talk about what soft skills actually are, why they have always been important in software development, and why I believe they will become even more valuable in the age of AI.
What Are Soft Skills?
When people hear the term soft skills, they sometimes think these skills are less important than technical skills. I disagree. In many cases, they are actually harder to develop.
Soft skills are the skills that allow you to work effectively with other people. This includes communication, collaboration, critical thinking, problem solving, leadership, time management, adaptability, empathy, and decision making.
Think about your average day as a software developer. How much time do you actually spend writing code? Probably less than you think. You attend standups, review pull requests, discuss requirements with product managers, participate in design meetings, answer questions on Slack, help other developers, estimate work, and provide feedback during code reviews.
All of these activities require soft skills.
Some of the best software developers I have worked with were not always the smartest people in the room or even the strongest programmers on the team. They were the people everyone wanted to work with. They communicated clearly, listened to others, asked good questions, and earned the trust of the team.
These skills have always been important, but I think AI is going to make them even more valuable.
AI Doesn’t Understand Your Business
Over the course of 20+ years, I have worked with many different companies across different domains. This includes oil and gas, energy, retail, healthcare, insurance, and several others. The most difficult part of working in all these different industries was usually not the technical challenges. It was understanding the business.
Most technical problems could be solved by searching Google, reading documentation, asking another developer, or trying a few different approaches. Today, AI makes this process even easier. You can describe a technical problem and get several possible solutions within seconds.
Domain knowledge is different. It takes time and effort.
Over the years, I have found that one of the best ways to understand a new domain is to take a domain expert out for lunch. During lunch, you can ask questions about how things actually work. Why do we have this process? Why does this person need to approve this? What happens when this particular situation occurs? Why can’t we remove this step?
That lunch can sometimes be the best investment you make in the project.
AI can explain how an insurance claim is generally processed or how a hospital scheduling system works. But it doesn’t know exactly how your company processes claims. It doesn’t know why a certain approval requires three signatures. It doesn’t know that a business rule that looks completely unnecessary exists because of a legal requirement or a contract with an important customer.
You learn these things by talking to people. You learn them by asking questions, attending meetings, and working closely with domain experts.
I have always found developers who understand the business to be extremely valuable. When you understand the business, you are no longer just waiting for someone to give you a ticket. You can participate in the discussion. You can question requirements. You can suggest alternatives. Sometimes you can even tell the team that the feature they are planning to spend two weeks building is not needed at all.
AI can help you write the code faster, but someone still needs to figure out what should be built.
Asking Better Questions
I think asking good questions is one of the most underrated skills in software development.
Imagine a product manager asks you to add a button to a screen. You can open your favorite AI coding tool and ask it to generate the code. Within a few seconds, you probably have your button.
But that was never the difficult part.
Why do we need this button? What happens when the user taps it? Who should be allowed to see it? What happens if the operation fails? Do we need a confirmation before performing the action? What problem are we actually trying to solve?
Depending on the answers to those questions, you may discover that you don’t need the button at all.
I have seen developers spend days implementing something only to find out later that they misunderstood the requirement. There may be absolutely nothing wrong with the code. It may be beautifully written and have excellent test coverage. Unfortunately, it solves the wrong problem.
AI does not fix this problem. If anything, it can make the situation worse because now we can build the wrong thing much faster.
Before asking AI how to implement something, make sure you understand why you are implementing it.
Learn to Communicate
Communication has always been a big part of software development. We communicate with product managers, designers, QA engineers, other developers, managers, customers, and many other people throughout the day.
One important skill is being able to explain technical concepts to people who are not developers.
Suppose a product manager asks why a particular feature will take two weeks instead of two days. You probably don’t need to explain every protocol, database table, API endpoint, or design pattern involved in the implementation. You need to explain the problem in terms that are useful to them.
The same thing happens when discussing technical decisions with other developers. You should be able to explain why you prefer one approach over another. What are the benefits? What are the tradeoffs? What problems are we trying to avoid?
I have been in plenty of meetings where developers spend a lot of time arguing about technical details that have very little impact on the actual product. Being technically correct does not always mean you are helping the team move forward.
Good communication also means listening. Sometimes another developer has more context than you. Sometimes the QA engineer knows about an edge case you haven’t considered. Sometimes the product manager knows about a customer requirement that changes the entire solution.
Communication is not just about explaining your ideas. It is also about understanding everyone else’s.
Critical Thinking Becomes More Important
AI can generate a lot of code very quickly, but that doesn’t mean the code is good or that you should use it.
This is where your experience as a developer becomes important.
When AI generates code, you still need to look at it and decide whether this is actually how you would solve the problem. Does it fit with the rest of the application? Is it adding unnecessary complexity? Are there security concerns? What happens when something fails? Is there a much simpler solution?
I use AI regularly when writing code, and sometimes it gives me a solution that works but is much more complicated than it needs to be. Other times it makes assumptions that are simply not true for my application. If you don’t understand the technology, it is very easy to accept whatever AI generates and move on.
This is one reason I still believe learning the fundamentals is extremely important. If you don’t understand networking, state management, databases, concurrency, architecture, testing, or whatever area you are working in, how will you know whether the generated solution is good?
AI can give you ten solutions in a few seconds. Your job is to figure out which one makes sense.
Sometimes the correct answer is none of them.
Working With Other People
Software development is a team activity. AI does not change that.
Even if AI eventually writes most of the code in our applications, we will still have product managers defining requirements, designers working on the user experience, QA engineers testing the application, security teams reviewing systems, and stakeholders asking for changes.
We still have to work with all of these people.
In fact, I think faster development may require even more collaboration. If we can build a prototype in one day instead of one week, we can get feedback much earlier. We can show it to users, discover problems, make changes, and try something else.
This means developers need to be comfortable receiving feedback and changing direction. You may spend several hours working on something only to find out that the team wants to go in a different direction. That is part of the job.
It is very easy for developers to become attached to their solutions. We spent time designing the architecture, writing the code, and solving difficult problems, so naturally we want to protect that work. But the goal is not to protect our code. The goal is to build the right product.
If the requirements change and half of your code is no longer needed, delete it and move on.
Take Responsibility for AI Generated Code
There is another thing I think developers need to understand when using AI. If AI generates the code and you put that code into your application, it is now your code.
You are responsible for it.
If it introduces a security vulnerability, you cannot blame ChatGPT. If it causes data loss, telling your manager that AI generated the implementation is probably not going to help. If the code does not satisfy the business requirements, the AI is not going to attend the meeting and explain what happened.
This is why I don’t like the idea of blindly copying and pasting AI generated code into an application. You should understand what the code is doing and why it works.
This doesn’t mean you need to manually write every line yourself. I don’t think there is any value in typing code just for the sake of typing code. If AI can generate something in 30 seconds that would take me 20 minutes to write, I am happy to use it.
But I still want to understand what I am shipping.
AI is a tool. Responsibility still belongs to us.
Technical Skills Still Matter
I don’t want this article to give the impression that technical skills are no longer important. They are extremely important.
You still need to understand programming fundamentals, architecture, databases, networking, security, testing, performance, concurrency, and the frameworks you use to build applications. In fact, you need these skills to properly evaluate the code generated by AI.
What I think is becoming less valuable is memorizing syntax.
I have been writing Swift for many years, but I don’t remember every API. I don’t need to. I can look at the documentation or ask AI. Knowing the exact syntax for something is not nearly as valuable as understanding the concept behind it.
Understanding why state should live in a particular place is more important than remembering the exact syntax for declaring that state. Understanding how concurrency works is more important than memorizing every concurrency API. Understanding why you should test something is more important than remembering every assertion available in a testing framework.
AI is very good at filling in those gaps.
The developer still needs to understand the bigger picture.
This is why I don’t think the future belongs to developers who only have soft skills. You still need strong technical fundamentals. But technical skills alone are not enough.
The combination is what matters.
The Developer’s Role Is Changing
For a long time, developers have been measured by how much they can build. How quickly can you finish the feature? How many tickets did you complete? How much code did you write?
I think AI is going to force us to rethink some of this.
If AI allows me to implement something in two hours instead of two days, that is great. But saving those two days does not matter much if we built something nobody needed.
As implementation becomes easier, I think developers will spend more time understanding problems, discussing solutions, evaluating tradeoffs, reviewing generated code, and working with people across the organization.
Maybe instead of immediately opening Xcode and starting to build a feature, we spend another 30 minutes talking to the product manager. Maybe we build a quick prototype and show it to the customer before spending a week on the complete implementation. Maybe we discover that the problem can be solved without writing any code at all.
To me, that is where software development becomes interesting.
The goal was never to write the most code.
The goal was to solve the problem.
Final Thoughts
I use AI every day, and I think it is an incredible tool for software developers. It helps me explore ideas, understand unfamiliar APIs, generate code, write tests, debug problems, and sometimes challenge my own approach.
But the easier it becomes to generate code, the more important the other parts of software development become.
Learn how to communicate with people. Learn how to listen. Ask questions when something does not make sense. Spend time understanding the business. Learn how to explain technical concepts without making them unnecessarily complicated. Learn how to disagree with someone without turning the discussion into an argument.
At the same time, continue improving your technical skills. Learn the fundamentals. Understand the tools you are using. Don’t blindly trust code just because AI generated it.
I don’t think AI will make good software developers less valuable. I think it will make the difference between developers who simply write code and developers who actually solve problems much easier to see.
And in the age of AI, I believe that difference is going to matter more than ever.