New CS grads and junior devs struggling to meet expectations

There's been a lot of talk about CS grads and junior devs struggling to perform in companies of all kinds over the last few years. Although not unique to software development, the mindset required to do well and thrive in a team of devs requires a lot of curiosity, independence, ownership, and passion.

There are a lot of people who will claim you can do intense jobs with no passion for the money, I don't believe the majority of people would recover from expected burnout from a career they don't like. Likewise, software development is a job you will likely fail in going just for money. There are some jobs that are much more slow paced (companies that aren't tech based and have minimal software), but not in most tech focused companies.

Back in early 2020, there was a boom in tech and a lot of people were being sold some golden pipe dream about software engineering and computer science. It's always been a lucrative field, but you have to actually be GOOD. A bunch of people started spending money on coding boot camps, college students going into computer science, and people trying to become devs on their own with no real structure.

A bunch of get rich quick tech influencers built garbage courses to sell to anyone who would breathe their direction. During this time, leetcode has become the gold standard to tech hiring and puts software engineers through the wringer for interviews. Leetcode (the platform) has raked in tons of money from people trying to pass all the questions to prepare for interviews and land a job.

Because of this, people have learned to memorize patterns and solutions to questions. If you press them for a different approach in the interview, they can't produce anything. There are many people who have not gotten caught during this method and made it to their first job - only to be pip'd in the first 3-6 months.

There are a lot of stories of Computer Science students graduating with nothing to show for it. No internships, no work experience, no personal projects, and lacking of the most basic computing logic. When I was a TA, this is something I saw with students even back then before ChatGPT. Students doing everything but actually paying attention to how to write programs well. No testing, no planning, no nothing.

This has been made worse with LLMs readily available for students to cheat their entire way through their major. They graduate and literally don't know anything.
Even when I was in college, a lot of CS professors mentioned that CS could be a very unemployable major because people didn't do the work to pass interviews or succeed in their first job. Now that there's a ton of those types of juniors, they've started to flip it into "this is flawed", "we should be able to use LLMs for interviews and work", "why do I even need DSA", etc.

If you need AI to dot he work for you, that means you don't have the skills. You can utilize the LLMs to help you as an assistant but to replace yourself entirely is stupid. Why would a company hire a junior engineer who refuses to actually learn and utilizes chatgpt 90% of the time? They could just have a senior do that + have all the knowledge in their mind required for better decisions than a junior could produce.

Some juniors I've seen also will say "well a junior + ai will replace a senior without ai". That will not happen. Ever. If it was happening we'd see more junior jobs instead of seniors being safe in theirs. Not only that, a senior will pick up AI significantly faster than a junior will and be able to solve the issues it will cause.

This is also why companies are not hiring junior people, not because they are unwilling to train them, but because a lot of juniors are unwilling to learn.

Programming interviews have been a thing forever, especially as whiteboarding. If you can't write out your thoughts and map out a solution on paper - you don't know enough yet. You're being hired on your ability to problem-solve and build solutions.

Not only that, you want to actually progress in your role as a software engineer. You don't want to stay at junior level forever. There is no way towards progress except straight forward. You will be obviously stagnated if you don't do continuous learning and have an effective goal for your career and role.

Recap on a few issues:

-People were memorizing questions and solutions to problems. When questioned during an interview they couldn't explain their code or answer how it would change with different parameters. They weren't actually solving the problem, just regurgitating solutions. Think back to math class when you would get a zero for giving answers without showing your work. The reason you were required to show work is because you were being tested on understanding the logic of the system. The answer isn't the most important part, the steps are.

-The one who could pass the interviews were getting pip'd within 3-6 months into the role because they couldn't deliver even as a new grad or junior. They didn't have the capacity to grow in their role and didn't showcase any ability to work with the team well enough to progress.

-Inability to work without AI. This one is a huge issue right now, but many juniors and fresh grads are not able to critically think about things without AI. This isn't everyone, but it's a sizable chunk. When you're a software engineer, you're being paid to critically and logically solve a problem. It includes design, build, maintenance, etc. If you don't understand the code you wrote, you can't demo it or showcase it. You won't be able to fix it, add onto it, or literally do anything.

My advice for up-and-coming devs:

-Be curious and interested in how processes work. Take some time to really see how other engineers work, what they work on, and how they succeed.

-Take ownership! Allow yourself to take ownership over the tasks given to you, but also own up when you've made a mistake (and make sure to learn from it!)

-When I was in college for CS, I interned at NASA twice for SWE. The leaders there said the top reason for interns to not get callbacks is their inability to listen to those around them (especially older and more experienced) as well as rushing into new technologies all the time. New people thought they knew everything and refused to study the past to predict the future.

-When it comes to leet code and DSA, make sure that isn't the only way you know how to code. Understand the differences between coding in leetcode, doing hackathons, and actual programming for function at work.

-As you get more experience, pay attention to system design.

-Start collecting some computer science books. Some great reads are: The Software Engineer's Guidebook, The Pragmatic Programmer, The Mythical Man-Month, Structure and Interpretation of Computer Programs, Working Effectively with Legacy Code, and Pro GIT.

-Come to understand the business needs of your work. Think about how to make a larger impact and how your work can apply across the organization (i.e. Don't build redundant apps, think about who else in your org would benefit from your team's build)

-Learn to work effectively alone AND in a team. Both are required to succeed well. You should be in lock-step with your team but also be able to tackle independent projects without needing constant help.

-Learn how to problem-solve and debug well! When you get stuck, exhaust all of your options for self-learning before going to other engineers on your team (if time allows). This is for your benefit to become a better software engineer. Build a methodology for how to get unstuck.

-Go through your org's codebase and just read the code. Make sure you understand what you're looking at. Do not rely on other people to tell you how it works and also (please) do not dump proprietary code into an LLM. This is also for your benefit to become better at problem-solving.

-If you're at a company that allows use of copilot, cursor, or other AI tools - don't become extremely reliant. Make sure you continue to practice on your own, so coding efficiently becomes second nature.

-Practice white-boarding and planning how your program should look. You should be able to plan out all the factors, the potential hiccups, the storage, etc. It will also help you strengthen both critical and logical reasoning with building programs.