One of the first steps might be to view ChatGPT less as a source of quasi-autoritative learning material, and more as a tool that can help you figure out what to search for elsewhere. Looking up information ("google-fu") was one of the core skills before AI came along, and it still is. AI can be helpful, but it can also "hallucinate", as they say. This is because any LLM today is essentially making up a statistically plausible answer to your question/prompt - it's just that it's so good at it that it works a lot of the time. Strive to make Chat GPT (or Copilot, or whatever) just one of the tools in your toolbox, rather than the tool.

If you must use AI to generate code, then don't generate the bits you want to learn. Generate the supporting scaffolding code that you don't care about, but write the stuff you want to learn yourself. Yes, it will not be perfect, it might not even be just OK, but that's the point - you learn the most (and retain that knowledge the longest) by making your own mistakes, and by grappling with the problem, by getting stuck and then pushing through. By making a mess, then throwing it away and doing it again, but a bit better, cause you obtained some insight in the process.

Don't settle for easy answers. Instead, try to understand the "why" behind things. There's a lot of advice out there, design principles, "best practices", and a lot of what you'll find will be contradictory, poorly explained and apparently unmotivated. But do your best to figure out what the main points are, and what the reasoning behind it all is, and accumulate that understanding over time. Be aware that not every such principle or advice applies in every situation, and that "best practices" is a bit of a misnomer - for a lot of things, there are no truly best practices, only practices that work pretty well under certain conditions/assumptions. Therefore, building this understanding will be a challenging, long process, and you have to be OK with that.

Read as much as you can (books, articles, blogs, computer science papers), listen to talks (many conference talks are freely available on YouTube), etc. Many of these conference speakers have technical blogs, some have a YouTube channel, some of them have written books - so if you find someone who seems knowledgeable and is good at explaining things, look them up. Also, a lot of problems you'll encounter, people have encountered before, so if you just google the issue, you'll often find a stackoverflow question about something similar, and sometimes, answers will be surprisingly in-depth and information-packed. And don't limit yourself to your particular niche, and your particular programming language. There are valuable insights to be obtained from folks who are doing other things in other languages. These will recontextualize your knowledge and expand your horizons. Do learn at least a little bit about the low level stuff - what compilers actually do, how are things represented in memory, what memory looks like in modern computer architectures, etc.

Blogs and articles (and sometimes even documentation) will have links to other blogs and articles, and books, papers and Wikipedia articles will have references to other books and papers, so just follow the bread crumbs. Some bloggers will even have a page with recommended reading material. And, ChatGPT and Copilot can point you to sources of information as well, and search the web for you (although sometimes they will randomly claim they can't access the web, or will make up links, but that's just how it is with these services). You can find important insight even in old and "outdated" books and papers, so don't dismiss them. Some things in them no longer apply, but many do. Some of these older books are available for free on archive.org. Some books and papers, old or new, might come up in a google search, available as PDFs hosted on various university sites, or elsewhere. Papers might be available on arXiv.org, academia.edu, or personal pages of researches. Also, conferences will sometimes publish slides from past talks.

Another thing that's going to supercharge your learning is teaching others - there's always someone who has yet to learn what you have learned, and trying to answer their questions is going to reveal to yourself holes in your own understanding, and you'll want to patch them up cause you'll be invested in providing a good answer. The next thing you know, you're digging through blog posts, discussions, books, and writing code just to clarify something for your own sake.

"My go-to workflow is to ask Chat-GPT what's the best tech stack and then type out the sample project they provide"

That will get you started, but you'll learn very little by just typing things out. What you need to do is set for yourself small challenges that are just outside of your comfort zone, and attempt them. Something that you think you could tackle, but aren't quite sure yet how to do it. These can then turn into interesting side projects. You can learn a lot by reading, but you can learn more by doing - by trying things out, by testing ideas. And don't get discouraged if it's a bit of a struggle. Learn to be comfortable at the edge of the unknown. Try something out. Do an experiment, see what happens. If you get stuck, take a break, try again. It's even fine if you get so stuck that you feel kind of stupid, cause once you manage to figure it out, you'll be over the moon and it will all be worth it. All that is just how learning is - it's all perfectly normal.

And when you do figure it out, don't stop there. Go a few extra steps and try to improve it further in some way. Maybe clarity would be improved if you extracted some bit of code into a separate function. Maybe you can generalize your current algorithm so that it can work in a wider range of situations. Maybe you can tweak two seemingly different functions so that they look the same - then replace them with a single one. Maybe you find a way to simplify the code, and this then opens up possibilities you didn't see before, etc.

Also, don't worry too much the "best tech stack". That isn't so important, and will change over time - frameworks come and go. Yeah, you'll need to learn a few of those for your job, but over time you'll realize that they all fall into a small number of different categories, and you'll be able to pick up new ones easier because of familiarity with some other framework you've used before. And as convenient as they can be, they are also often a bloated mess designed to cover a range of use cases. Try also building something without them. Figure out what the minimal version of the application looks like, then play around with that - start small, then add features. This will give you some idea as to what the core of the application is, without all the distracting fancy bits. This might help inform how to make a better use of the full-blown framework, how to customize it, etc., cause it'll now seem a little less like magic.

Finally, find documentation for your tools (libraries, frameworks), and learn how to utilize it. Official stuff and popular libraries and frameworks will usually have a dedicated website, with technical documentation, various tutorials, a "getting started" page. In some cases, it'll be a website that's not official but is everyone's go-to site. Smaller or less widely used libraries might just have a README.md on GitHub. You can also find things like starter project templates and "architecture skeletons" on GitHib, though YMMV with these.

What you do want to pay closer attention to is the standard library of your language - have mastery of the most frequently used things, core data structures and algorithms, and then have some idea of what else the library provides (as in, what is it for), and where to find those things if and when you need them. Often, you can make your code simpler and more elegant by utilizing the standard library.

And don't get carried away too much by the fancy stuff. Focus on the fundamentals, and learn them well, and revisit them from time to time. Everything else stems from there.