How to Become a Better Software Engineer in the Age of AI
AI can generate code faster than ever, but does that make software engineers less important?
Not at all. In fact, the rise of AI makes strong engineering skills, technical fundamentals, and product knowledge more valuable than ever.
In a recent developer discussion, Professor Isidro and Luiz shared practical insights into what it takes to stay relevant and become a better software engineer in the age of AI.
Focus on Fundamentals, Not Just Writing Code #
AI tools can generate APIs, build applications, and even create entire infrastructures. But generating code doesn’t mean the result is reliable, secure, or scalable.
As Luiz explained, understanding software fundamentals helps developers guide AI and recognize problems before they reach production.
Consider a simple payment example:
- A customer clicks the payment button twice.
- Your application processes two payments instead of one.
- You need idempotency to make sure the same payment request isn’t processed twice.
- You also need to understand concurrency to handle requests arriving at the same time.
Without this knowledge, you might ask AI to build a payment system without realizing what could go wrong.
The key lesson? Learn the fundamentals so you can evaluate and improve the code AI generates.
Understand What’s Happening Behind the Code #
Professor Isidro emphasized that developers need to understand more than programming languages and frameworks.
Some important areas to study include:
- Databases: Learn data modeling, normalization, indexing, and query optimization.
- Data structures: Understand how data is organized and accessed efficiently.
- Operating systems: Know where your applications run and how they use system resources.
- Software architecture: Learn how to build reliable, maintainable, and scalable systems.
- Security: Understand authentication, authorization, and data protection.
You don’t need to become an expert in every subject. However, understanding the basics helps you make better technical decisions and guide AI more effectively.
As Professor Isidro explained:
How deep can you go with your fundamentals? You can go as deep as the assembly code or bytecode.
That’s a great reminder that software engineering is much bigger than writing code.
Become a Technical Leader for AI Agents #
The developer’s role is changing. Instead of writing every line of code, you’ll increasingly work with AI agents that can develop features, write tests, and review software.
Think of yourself as the technical leader of a team of AI agents.
Your responsibilities include:
- Breaking complex tasks into smaller pieces.
- Giving agents clear instructions and requirements.
- Reviewing generated code and pull requests.
- Checking whether tests cover important scenarios.
- Verifying performance, security, and reliability.
- Accepting or rejecting solutions based on technical quality.
AI can do much of the implementation, but you still need to understand the results.
Remember: Using AI doesn’t remove your responsibility for the software you deliver.
Get Closer to the Product and Your Customers #
One of the most interesting points from the discussion was that technical knowledge alone isn’t enough.
Professor Isidro explained that product managers and business professionals can create solutions quickly with AI because they understand their customers’ needs.
Developers often focus too much on architecture, frameworks, and technical implementation while forgetting the actual problem they’re trying to solve.
As Professor Isidro put it:
We have to be more strategic. We have to listen to the customers of our company. We have to participate in meetings with our customers.
Here’s what you can start doing:
- Join meetings with customers and product managers.
- Ask questions about real business problems.
- Understand the rules and processes behind your application.
- Focus on delivering useful features instead of unnecessary complexity.
- Improve your product based on customer feedback.
The goal isn’t just to build technically impressive software. It’s to build software that solves real problems.
Measure Success by Value, Not Lines of Code #
AI can generate thousands of lines of code in seconds. This makes traditional productivity measurements less useful.
Counting pull requests, commits, or lines of code doesn’t tell you whether a team is delivering value.
Professor Isidro highlighted an important shift: “Code is cheap. Software is expensive.”
Think about what really matters:
- Did you solve a customer problem?
- Did you improve the user experience?
- Did you deliver a useful feature?
- Is the application reliable and maintainable?
- Did you reduce unnecessary complexity?
A small change that solves an important problem can be more valuable than hundreds of lines of generated code.
Focus on outcomes, not output.
Keep Learning and Don’t Let AI Make You Lazy #
AI is an excellent learning assistant. You can use it to explain concepts, explore unfamiliar technologies, and understand code examples.
But there’s a danger: becoming so dependent on AI that you lose the ability to solve problems independently.
A practical learning approach is:
- Try solving a problem yourself first.
- Use AI to explain concepts you don’t understand.
- Implement the solution with AI assistance.
- Review every important part of the generated code.
- Explain how your solution works without AI.
Luiz also shared an interesting teaching approach: students can use AI during their studies, but they must explain the concepts and demonstrate how their code works.
This is a great habit for professional developers, too.
As Luiz reminded us: “Foundations are very hard to learn, but it pays off.”
Don’t skip the learning process just because AI can give you an immediate answer.
Final Thoughts #
AI isn’t making software engineering disappear. It’s changing what makes a great software engineer.
The developers who stand out will combine strong technical fundamentals, problem-solving skills, product knowledge, and the ability to work effectively with AI.
Keep studying, stay curious, understand your customers, and never stop learning how software works.
Don’t aim to become the fastest person at generating code. Aim to become the engineer who knows what should be built, why it matters, and how to make it reliable.