Table of contents:

• Introduction
• Why personal growth must be matter for juniors?
• Employer objective
• Work smarter, not harder
• Damages
  • Problem-Solving and creativity
  • Junior life
  • Doom loop
• To Junior developers: Be an expert not a labour
  • Be patient and proud of yourself
  • Debugging and reading codes
  • Never ask AI for solutions
• To Senior developers and Managers
• Conclusion

Introduction

AI-powered code completion tools designed for developers (commonly known as CoPilot) have become a significant trend in recent years. You may have heard about them frequently or even received encouragement from your employer or team lead to start using them. Business owners have discovered a new way to boost team productivity, this time through technology itself, rather than traditional staff management strategies. While there’s no denying the power and innovation behind this technology, it’s important to recognize its potential as a double-edged sword. This is why I feel compelled to share my concerns, particularly with young software developers.

This blog focuses on the long-term consequences of using CoPilot, rather than its short-term or occasional benefits. Through this discussion, I aim to address some important and compelling questions:

• Does this tool help us build the knowledge and deep understanding we need to rely on during critical moments, such as layoffs or when pursuing opportunities at other companies?
• Does CoPilot give us wings to fly or chains that hold us back?

The level of risk associated with these tools varies from person to person, depending on how the tool is being used and the developer’s level of experience. For junior developers, the impact can be especially significant and potentially more severe. If you’re a junior developer, it's crucial to approach these tools with caution. Let’s explore how these AI-powered tools might unintentionally jeopardize your career as a developer.

It’s worth mentioning that I won’t be addressing technical or code-related concerns in this blog, as there are already plenty of excellent resources out there that cover those topics thoroughly. Repeating them here wouldn’t add much value. Instead, I’ll focus on this phenomenon from the perspective of its potential career side effects. My goal is to understand how tools like CoPilot could impact your professional growth and offer strategies to ensure a win-win scenario-one where you benefit from this technology without just being exploited by some employers to produce more.

Why personal growth must be matter for juniors?

Whether we like it or not, everyone's expertise is a commodity to be sold in this market. We trade our time and knowledge in exchange for wages. Typically, those with more knowledge tend to earn higher wages. Without accumulating knowledge and insight over the years as developers, people are inevitably doomed to face a risky job situation in the future.

This is why, while working towards collective milestones within a team, young developers should also focus on improving their individual skills, especially during the first three years of their careers. This period is crucial, as it can shape the path of their professional growth. Unfortunately, it is also the time when many junior developers are most vulnerable to being taken advantage of, often leaving them with little valuable experience to carry forward in their careers.

In such a competitive environment, it's important to remember that whatever we hear from our employers may not always align with our best interests.This is why every developer should also set their own personal priorities for growth.

Employer objective

What motivate employers to encourage their IT employees to use CoPilot is the desire to increase the productivity in software development. Simply put, their goal is to enhance the pace of the team, pushing it to a higher output rate, whether that’s 1.25X, 1.5X, or even higher. The extent of this improvement depends on how the team adapts to the tool.

However, this productivity boost isn't limited to the developer realm alone; it also impacts business analysts, QA testers, and other stakeholders within the organization. While this broader impact might not seem like an immediate concern, for now, I’ll set aside this aspect and focus on the developer perspective.

Work smarter, not harder

You’ve probably heard this phrase before, likely from software "celebrities" or others trying to encourage developers to use CoPilot. Frankly, the idea of "working smarter" makes me uneasy, especially when it’s framed in such a simplistic way. It makes me think twice whenever someone whispers it in my ear. The motto "Work smarter, not harder" is deceptively tricky. In this context, "smarter" often implies taking shortcuts, but the truth is, you can’t become an expert by relying on shortcuts. Some influencers might subtly nudge you in that direction with misleading statements like these.

There’s no doubt that CoPilot is a powerful, helpful, and useful tool. But the key question is: helpful to whom? It would be naive to assume that CoPilot is automatically in the best interest of young developers unless they are taught how to use it properly. Sure, CoPilot can bring moments of relief, like when you’re stuck on an annoying bug that it helps solve in seconds instead of hours or even days. But these moments are rare exceptions. They bring fleeting pleasure, not long-term happiness or growth.

Damages

Problem-Solving and creativity

I've recently learned an interesting fact about role of Serotonin in our body from a friend of mine, who is a physician. I'm going to make an analogy through which we can understand better how reliance on such tools for long time can have unintended consequences on our brain.

Serotonin is a chemical in the brain that helps regulate mood, emotions, and other functions. The human body and brain naturally strive to maintain balance, a process called homeostasis. However, when serotonin levels are artificially increased for long periods (such as through medications or supplements), the brain may adapt by producing less serotonin on its own or becoming less responsive to it. This can lead to a dependency on external sources to maintain balance, making it harder for the body to regulate serotonin independently.

A similar concept applies to software developers relying on AI tools. Just as the brain's natural serotonin processes can weaken when rely on external boosts, a developer’s "learning nerves" (the neural pathways in the brain responsible for problem-solving and independent thinking) can become weaker if these skills are not regularly exercised. Over time, this can hinder creativity, diminish problem-solving ability, and reduce the capacity for independent learning, which are all essential for growth and innovation in software development.

This phenomena is not just in the software world but there are people who ask ChatGBT for each and every single decisions on a daily basis. From which series to watch, which food to cook all the way to which product is better to buy. Regardless of damaging the independent decision making power, it makes us vulnerable when a new generation of AI suggests who you should vote for in elections. A system that knows us better than ourselves by gathering our data. The Age of Surveillance Capitalism.

Junior life

Junior developers are often in a tough spot because they don’t have much experience yet. They want to prove themselves to their colleagues and employers, but there’s so much they need to learn. This pressure can lead to long hours of overwork. On top of that, they can’t always detect which skills or experiences will be useful in the long run, so they try to do everything they can to fit into their new environment.

This is the moment that seniors should step in to prevent soft exploitations and with an empathic guidance not only save them but also invest in a long lasting bound and connection in the small world of software development.

However, code completion tools would not allow them to flourish. CoPilot often feels like a quick fix, it helps them deal with the pressure to be more productive, meet employer expectations, and show their managers and coworkers they’re capable. While this is a natural reaction, there’s a danger to relying too much on it. Psychology shows that people who overgive and overextend themselves especially when they do it compulsively often become burn out, and end up being undervalued. At the same time, those who benefit from their overgiving can start expecting it and take them for granted.

This creates a harmful cycle, a "doom loop", where junior developers work harder and harder to meet expectations but don’t get much in return. Without help from mentors or guidance from senior developers, they get stuck in this cycle and miss out on real growth.

Doom loop

The doom loop starts when junior developers rely too much on tools like CoPilot to handle the pressure. Over time, they set a high standard of productivity in the minds of their team. But junior developers need time and space to learn while working on tasks independently, something they often sacrifice under these circumstances.

Eventually, they might notice the gap in their skills and want to slow down to spend more time learning. However, by this point, it becomes difficult to lower the bar and reset the team’s expectations. Trying to adjust can send the wrong message to managers and colleagues, making it seem like they’re falling behind.

Developers with strong communication skills may be able to change this situation and reset expectations with the team’s help, but unfortunately, many struggle to do so. For those who can’t catch up in time, the pressure can pile up, leaving them vulnerable to burnout or even layoffs. In such cases, losing a job can also mean losing a passion or even a career altogether.

It’s very hard for developers to break out of this loop on their own. Managers or colleagues with keen sense for observing issues in the team can intervene and stop the cycle.

To Junior developers: Be an expert not a labour

We’ve talked about many concerns so far, so now let’s focus on how to use CoPilot safely.

As its name suggests, CoPilot is just an assistant, not the decision-maker. You should always be the one making the final decisions and taking full responsibility for your code. CoPilot may have access to more information than we do, but it doesn’t have the wisdom or judgment that comes with human being. That’s why it’s important to use it the right way.

Always remember: what makes you an expert is your own knowledge and skills. CoPilot can help you along the way, but it’s your expertise that truly matters.

Be patient and proud of yourself

When I was a child, my father gave my older brother and me a unique challenge. He brought us a piece of marble, about the size of a child's fist, from one of his friend's stone factories. Our task was to shape it into a marble sphere using just a hammer. It seemed simple at first, but we quickly realized how delicate the process would be.

It took us weeks to complete the project. During this time, I learned an invaluable lesson: patience and precision are key. Every strike of the hammer had to be gentle and calculated, as a single careless hit could easily split the stone in half. For a child, full of enthusiasm and impatience, controlling each and every strike was a real challenge. But as the days passed, I discovered the importance of persistence and the truth behind the saying, "Good things come to those who wait."

This childhood lesson has stayed with me throughout my life, and it applies to many situations, especially when learning something new or tackling challenges that seem overwhelming. It’s perfectly fine not to know everything at first. Whether you're learning about software, technology, or any other field, it’s okay to feel like you know less than your peers. Take your time. Give yourself the space to grow. Be proud of the progress you make, no matter how small it may seem. Focus on comparing yourself with who you were yesterday not with anybody else. Remember, just as I learned with the marble, rushing the process can lead to mistakes, like splitting the stone in half. True growth comes from patience, persistence, and trusting the journey.

There are a lot of possibilities that you get the best out of CoPilot and use it as a sharp knife in your kitchen.

Debugging and reading codes

Debugging is one of the most important skills for developers. The only way to build this valuable skill is by setting breakpoints in the code and getting your hands dirty, again and again. It takes practice. At the same time, reading other people’s code can feel overwhelming, but it’s also a key part of becoming a better developer. This is where CoPilot can be helpful. You can ask it to explain what’s happening in a piece of code or even in an entire project. However, don't accept the CoPilot's explanation blindly, always try to connect its explanations to what you see in the code yourself.

If there’s a part of the code you don’t understand, you can also ask CoPilot to identify for example which software design patterns is being used. Once you know the pattern, you can read more about it and see how it works. It’s much easier to understand and learn design patterns when you see real-world examples like the code you’re working on.

Think of CoPilot as a tool for guidance, it can point you in the right direction, but you need to reach the destination yourself. When you figure things out on your own, you’ll feel much more confident. And don’t forget, Google and Stack Overflow are still some of the best resources for deeper research. If CoPilot doesn’t give you the answers you need, those two are always there to help.

By using CoPilot this way, you’ll meet its true purpose: to assist you. The key difference is this; are you the leader, or are you being led by a machine? Always aim to lead.

Never ask AI for solutions

Look at a solution as a final destination in software development. But, as they say, the journey is where you learn the most. Those moments of struggle and exploration broaden your perspective and help you grow. Jumping straight to the conclusion often means missing out on valuable learning opportunities.

Don't lose the chance to learn, otherwise, you have to pay a significant price to gain the same experience in future. Every task is a chance to make your problem solving and creativity skills, stronger; to challenge your mind; to explore more; even if you don't like the nature of the task. So don't miss these precious opportunities by asking CoPilot for solutions. As we saw earlier this can make learning nerves in brain weaken.

If you’ve tried multiple times and still can’t solve the problem, that’s the perfect time to reach out to your colleagues. Listen to their thoughts and compare their approaches to develop your own insights. This will help you view the problem from different perspectives. Remember, there’s rarely a single "right" or "wrong" solution in software, it’s all about trade-offs, like cost, maintainability, and complexity. Many of your colleagues’ solutions may work, but to better evaluate them and understand their pros and cons, you can use AI tools like CoPilot to spot pitfalls or analyze alternatives.

Even if you’ve already found a solution, discussing it with your colleagues is still valuable. They may not think your solution is the best, but you’ll gain insight into how others view the problem. After improving your solution based on their feedback, you can again use AI to weigh the pros and cons of your updated approach.

Keep in mind that AI responses aren’t always accurate. To ensure reliability, double-check AI-generated insights with senior colleagues.

Programming is ultimately about collaboration and negotiation with your team. When you make your teammates feel safe, secure, and involved, they’ll be more willing to help you with genuine smiles. If you want to improve your negotiation skills, this book is a great resource to get started.

To Senior developers and Managers

As I mentioned earlier, there are moments and places where you can make a real difference in someone’s life. You have the chance to leave a positive impact on their future. And here’s something important to remember, it’s not always about the code. A few years from now, no one will care about the strange abbreviations we picked for our system names. No one will remember our sophisticated solution for a bugs or incident. No one will remember the top-notch system we designed.

Now I want you to pause for a moment, look back on memories of all those years of working. What has stayed on your mind?

What people will remember are the small, meaningful moments. It’s the time someone stood by you and support you in your darkest hour. The time someone made you laugh when you felt like giving up. It’s the deep empathy someone showed by truly listening to you and tried to see things from your point of view.

These moments matter more than any technical achievement. They define us, both as professionals and as human beings.

Let me leave you with a timeless Persian poem by Saadi Shirazi, written in the 13th century:

Human beings are members of a whole

In creation of one essence and soul

If one member is afflicted with pain

Other members uneasy will remain

If you have no sympathy for human pain

The name of human you cannot retain.

Conclusion

In conclusion, while tools like CoPilot offer undeniable advantages in boosting productivity and simplifying complex tasks, they should be approached with caution, particularly by junior developers. True growth comes not from shortcuts but from engaging deeply with challenges, honing problem-solving skills, and building expertise over time. CoPilot can be an invaluable assistant, but it must not replace the critical thinking, creativity, and collaborative spirit that define successful developers. For senior developers and managers, the responsibility lies in guiding junior team members, fostering their growth, and creating an environment where learning and empathy take precedence over mere output. By striking a balance between leveraging technology and nurturing human potential, we can ensure that CoPilot serves as a tool for empowerment rather than dependency, enabling developers to soar rather than stumble.