As a software engineering manager, I’m constantly reminded of the value AI brings to our work. It can generate boilerplate code, suggest basic implementations, and assist with simple debugging tasks and help us to write some tests. But while it’s an undeniably powerful tool, there’s a stark boundary to what it can and cannot accomplish in my opinion. This distinction is crucial for software leaders and developers alike to understand. Removing the FUD that is at times associated with the use of AI for software engineering is important.
I prefer to think of AI as a hyper-efficient lesser experienced developer who can type at blazing speeds and knows a bit about nearly everything. It’s helpful, yes, but still a junior team member, lacking the experience and context to make crucial, high-level decisions.
AI excels at:
- Generating boilerplate code: When I need the basic framework for a class or function, AI can produce it in seconds. Need to new up the basics of a quick POC project? AI can do that quickly and efficiently. It’s a timesaver and lets my team focus on more challenging tasks.
- Suggesting basic implementations: For standard algorithms or common patterns, AI can provide workable solutions that are often close enough to be useful without major adjustments.
- Simple debugging: When it comes to locating obvious issues, AI’s suggestions can be a quick win, pointing out syntax errors, missing imports, or overlooked conditions.
But there’s a significant difference between assisting with code and engineering the broader software landscape. When it comes to the big-picture decisions, AI falls short. Here’s what it can’t do, at least in my opinion yet:
- Design scalable data patterns: Building scalable systems isn’t just about putting data into tables or creating CRUD APIs. AI doesn’t understand the underlying data relationships or the scalability considerations necessary for a production system.
- Optimize rendering strategies: Performance is often a nuanced matter, especially in complex applications. AI can recommend general optimizations, but it doesn’t grasp the specific requirements that may vary across use cases, devices, or network conditions.
- Make architectural decisions: Software architecture goes beyond surface-level code. It’s about aligning system design with business goals, team capabilities, and project longevity. AI lacks the depth of experience and insight required to handle this.
- Understand your business context: The most significant factor AI lacks is understanding your business’s unique needs, users, and strategic priorities. Only a human, fully immersed in the company’s mission and goals, can make these calls.
In other words, AI can help with the "what" and the "how," but it’s up to us to decide the "why."
Here’s Where You, as the Engineer, Make the Difference
Building successful software is not only about getting the code to work; it’s about ensuring that it continues to work, remains maintainable, and scales as the user base grows. To make software that truly succeeds, you need to consider things AI simply cannot anticipate. As an engineer, you must know:
- How to structure your data fetching: Deciding when and where to load data, how to cache it, and what data access patterns work best is a complex balancing act. AI might suggest techniques, but understanding the impact on the system overall is your responsibility.
- Why certain performance patterns matter: Caching, batching, and memoization are some of the tools we rely on for efficient performance. But the reason behind choosing one approach over another depends heavily on your users and your application’s real-world requirements.
- Where to implement strategies, patterns, and practices: Knowing when to use a specific design pattern or apply a particular optimization often requires contextual insight. Each decision impacts future development, maintainability, and potential tech debt.
Ultimately, while AI can suggest the “right” code, only you can determine the right solution.
The Real-World Difference Between Working Software and Scalable Software
Scalable software requires insight, experience, and an understanding of both technical and business needs. AI, with all its power, is still code-blind to these distinctions. It can suggest answers, but it can’t evaluate trade-offs, weigh future risks, or envision the system holistically.
The difference between working software and scalable software lies in the decisions that only you can make. These choices shape the future health of your codebase, ensure your application’s longevity, and align it with your business goals. So, use AI as a valuable assistant—embrace its ability to streamline routine tasks and accelerate the mundane. But always remember: the essential engineering decisions remain firmly in human hands.