​

Companies are mandating the use of AI coding agents, and honestly, it makes sense.

In the corporate world, you're responsible for outcomes, not the amount of code you personally type.

Whether you wrote it or an agent wrote it, they really don't care. Trust me, it hurts to say this as someone who genuinely enjoys the craft of writing code, but it's the truth.

AI is here to stay, and it will be incorporated more and more into what we do as software engineers. Some companies are beginning to allow the use of AI in technical interviews! I am excited to see what that will evolve too!

The reality is that these tools make you more productive when used properly. But I believe there's a right place and time for them. I've broken it down into three key areas:

Questions and Understanding

Pretty much any question you have regarding a codebase, a design pattern, or a library, AI agents are great for these.

Think about what you used to ask on Stack Overflow, or what you would spend hours digging through documentation or code to find.

AI agents excel at explanations because they have a lot more context than we do, especially when they're plugged into the codebase correctly.

Whenever I need to make a big change and need to understand how it might ripple through the system, I'll typically ask the agent first.

You can also ask for implementation details, architectural insights, or even "where should this functionality live?"

This saves hours of context-switching and reduces the cognitive load of keeping an entire system in your head.

Debugging

This is where some nuance starts to come into play.

AI agents can be great at debugging, but I do recommend reading the stack trace first and trying to figure out what the issue might be before handing it off to an AI agent.

The reason? If you immediately throw every error at an AI without understanding the problem, you're not learning the patterns of what breaks and why.

You're also gradually watering down your problem-solving skills.

I suggest you read the error, form a hypothesis, and if you're stuck or want to validate your thinking, then bring in the AI.

It's incredibly helpful for suggesting fixes, finding edge cases you missed, or identifying issues in unfamiliar parts of the codebase.

Design and Implementation

This is where I believe there should be the most nuance and intentionality.

You can absolutely use AI agents as a sounding board for designs, asking questions about the pros and cons of doing something a specific way, but you should ultimately pick the direction.

If you don't have a direction or an understanding of what needs to get done, solely relying on AI agents to figure things out for you is not sustainable.

At the end of the day, you'll end up with a system you don't truly understand because you didn't design it. You'll struggle to debug it, extend it, or explain it.

Once you've figured out what needs to be done, giving the agent complete context about what to do and where to do it is where it really shines.

Otherwise, it starts to fill in details that aren't there and make assumptions that don't align.

The way I keep myself accountable is by looking at the size and specificity of my prompts.

If it's a one-liner that's not a question, then I clearly haven't done enough thinking, and I'm not giving proper instructions.

However, if it's a multi-line prompt like "Go to this file, find this method, write a similar method that does X, Y, and Z, and place it in this module", then I know I have done some thinking.

I have the direction and am just delegating the implementation, which I could do myself, but would take significantly more time.

AI agents are also excellent at writing tests, specifically handling complex mocking, but you have to tell them what flows and scenarios to test.

There are also times when I believe writing the code myself will teach me something I haven't done before or expose me to business logic I haven't encountered.

In those instances, I lean towards writing the code manually.

I'll still ask specific questions along the way, like "How do I extract this property from this nested object?" or "What's the idiomatic way to handle this in this framework?".

The Bottom Line

Agentic software development is here to make our jobs easier.

The amount of traffic to Stack Overflow has significantly decreased because AI can do everything Stack Overflow used to do faster, with more context, and without the snark.

I believe the future is agentic software development, but we have to be careful about how we use it.

If used correctly, AI agents can be assets that help you be more productive and ship code faster.

If leveraged incorrectly, they can atrophy your skills, leaving you overly dependent on them for code you didn't write and don't truly understand, digging yourself into a hole that the AI agent might not be able to pull you out of.

My advice? Stay curious, stay intentional, and never lose sight of the fundamentals. Always understand the core of what you're building, where things live, why they're structured the way they are, and how it all connects.

Let AI handle the tedious parts so you can focus on the interesting problems, but never let it do all the thinking for you.

Uma