How do you learn without AI?

You read the documentation of whatever you use

So if I want to work in Go, I should just read through the documentation for Go to figure out what projects it would be best for?

It makes me sad that this is what learning to code has become. By using ChatGPT to generate your project concept and tech stack, you're giving away a lot of the autonomy over your project's structure and losing out on (in my opinion) one of the most important parts of programming.

I don't have a 5-steps-to-ditch-ChatGPT life hack for you, but I can tell you how I learned to code a few years before LLMs became popular.

Identify a project

Probably the most important step, this should be a project that you're passionate about and want to spend time on. It doesn't actually matter what the project is, but it does matter that you're interested in it.

Pick a Language / Framework / Library

If you want to learn a specific language, you should be considering this when you pick the project. If you want to learn the best language for your project, Google "Go vs TypeScript for web server" and you will find six Medium articles explaining pros and cons of each. You can do the same thing for libraries within that language; the most important part is not to ask "what is best", but to ask "how do these compare", so you can get a sense of what trade-offs you're making.

Start

This part can be hard, but there are almost always sample projects or skeletons provided by the library or the language, or third parties. They will help you get past the overwhelming part at the beginning where you don't know what you're doing, but be careful to not rely on them too heavily. You should use them as a reference resource, not as a destination.

Examples will also often be embedded in the documentation. Some projects (React, Svelte, and Go, to name a few) have pretty great introduction resources from the project maintainers. Always take the time to try these if they exist, because they will answer the questions you won't know to ask.

Keep Going

I would always try to find an answer in the official documentation first, but if you can't, a general Google search will often get you what you want. If it doesn't, your question is probably too specific, and you will want to try making it less about your code and more about the behavior you want/don't want. This can also be a time to ask on Stack Overflow; be sure to read the "How to Ask"" guide.

Ok, that's my unqualified advice. Also, maybe take a computer science class if you're in school and your school offers them.

AI does improve learning by at least being a tool that can explain what code does. So unless you want to avoid it altogether, it is a good way to explain what a technology is good for and what the usual applications are. (LLMs are probability machines after all.)

If you want to avoid AI altogether, or learn in a more structured way, there still are tutorials and courses that teach a technology. For Go, you could check for example A Tour of Go. There isn't necessarily a need to read the documentation from start to finish, but the documentation pages usually contain an explanation of what it is used for and tutorials of common use cases.

If you want to know what kind of solutions a technology is good for, I would just google it. There are many blog posts and forums discussing the experiences developers have had with a piece of technology where you can learn more about it. These days AI is good for exactly this, though.

• you look at open source examples written by people with a clue.
• you read tutorials written by people with clues.
• you read the documentation of the libraries you are using.

Great this was helpful, specifically pointing to documentation, open source and medium articles. I'm looking for sources of information and it seems like those are going to have what I need. Thanks!

The problem with your question is, what are you learning with AI? If you're using AI and learning to program, then what is the problem?

We used to have this same question in a different form, "What if you're coding and you don't have the internet?" What do you need, documentation, compiler, libraries. Then you need to learn to navigate your documentation.

I am an expert at using the Java Javadoc. They are excellent. They conform to the JLS. Navigating these documents are a skill in of itself. You're just not going to get that without some experience.

There is a thing called "learn by pain". I think that is what AI code agents are encouraging. You don't learn the proper way things should be done; you learn a way they can be done, and then you have to fix everything.

Tangential: this question baffles and disturbs me. There are books, tutorials, classes, bootcamps (many sketchy), documentation, etc. We have literally never had more resources available to us. None of them need or require AI in any capacity, and most of them relatively low-cost, some even free. Have you learned nothing without AI yet? How did you do that? Haven't you identified any generalized learning patterns sans AI? I literally don’t understand.

Also tangential: The best stack is the one that lets you put something into the world, because that's the only way you can get the idea, or learn how it could've been done better, or determine if how the framework works messes with how you work.

Before AI, there were forums, IRC, Discord, Wikipedia, books, and good search algorithms without ads.

IRC/Wikipedia discussions used to be more active, and you could ask someone more knowledgeable than you, and they could help you if you have time. Books were also there in the library if you had resources to afford them, or knew your ways to obtain them.

There was source code from GitHub. How did these guys do it? Just read other people's source code; do you understand it? Run it with a debugger step by step, and slowly get into it. But nowadays this is more painful to find with the search engines of today. You will not get what you need and you will get more distracting information. The days of old past are not the days of today. If you ask a question on IRC today, it will be less likely or the time delays will be longer than back in the day, as there are fewer people doing it, so you might be in a disadvantage today if you learn the same way you used to learn it before. You might just have to put in more effort.

(I know this is literally the opposite of what was being asked, but I recognize that it can be value. Ignore this if, for example, your job just doesn't allow you to use it, but allows you to do research.)

You just need discipline. However, learning from AI is not bad as long as you are disciplined. You must refuse to take code the AI says; critically verify that the code of the AI works.

AI will bullshit you and cheat you, but sometimes AI saves you hours of research/documentation by simply regurgitating the calls of the library you want to use. It doesn't mean the calls are up to date, so read the documentation. Sometimes the documentation is really bad, and you must read the source code. This can take up days by hand.

AI is a tool. It can summarize, it can find, and it can help you quickly onboard yourself on a repository, but it can't plan, it cannot think, and it cannot focus over the long term. It has a very short sightedness view to it, at least currently.

But as always, just try stuff and find out, questions of the type? (Is this possible?) Just do it. And see for yourself.

I taught myself computer programming before AI became mainstream, and I still elect to avoid using AI tools because I know they can be unreliable or introduce security vulnerabilities if their output is not inspected closely. Often the process of auditing AI code offsets any productivity gains it provides, so I commend you for your desire to actually learn how to code.

Every programmer's journey will be different, and what works for one person may not work for everyone, but I will share my experience here in the hopes that it will be useful.

I first learned about programming when I was given an Arduino Uno as a kid because I wanted to build robots and LED displays. I started by reading the official Arduino book, then modifying those examples in the IDE and running my own code. Eventually, after lots of iterative testing and research on Github and blogs, I had gone from my first program ("sketch", as they are called in the Arduino world) which simply flashed a red, green, and blue LED alternately in sequence, to displaying custom graphics on a 32x32 LED matrix and even playing text-to-speech files over an 8Ω speaker. Today, I don't do much with hardware anymore as I now am developing apps for iOS.

What matters here in my opinion isn't the particular resources or technologies used, but rather finding a project you are passionate about and then starting from the smallest possible unit. If that's writing a server in Go, start with the net/http documentation and a simple 'Hello World'-style script (such as this server), then work on adding your own application specific methods and eventually adding HTTPS support. If your goal is writing a messaging application, perhaps start with learning how to build a beautiful user interface with React (again, building step by step and adding complexity iteratively rather than all at once). Then, after you have something working, try to make it interface with your backend server, perhaps starting off with a simple mock "echo" server that simply replies with your text before moving on to handle user management, encryption, etc.

I personally find that this method of small steps makes learning more accessible and engaging. Seeing an application slowly develop over time is a much better motivator than trying to do everything all at once, and then spending hours debugging. And if you do choose this approach, it is important to augment it with continuous learning so you are aware of potential pitfalls such as security vulnerabilities, UI bugs, and (especially in the case of Go) concurrency-related problems such as deadlock. However, be warned that many of these issues may seem very abstract and/or unlikely (at least they did for me), but once your first Go program dies in deadlock you will quickly see the importance of these essential considerations. And that is something that AI can't do for you (at least right now): The AI will always generate code that looks correct, but it will be far less obvious if something has gone wrong than if you have built iteratively step-by-step and know exactly which line of code caused the undesirable behavior.

That also helps you generate a minimal reproducible example, which is essential for getting help on Stack Overflow. Never underestimate the power of this forum for learning programming &em; a simple web search of your problem or question will often reveal many Stack Overflow questions, and reading through these and the answers is an invaluable debugging resource, especially when you are first learning. And by doing this, you significantly reduce the likelihood of asking a duplicate question which may get closed and/or downvoted.

In summary, start small. Learn from books, official documentation, blogs (but make sure they're from real people, as "AI slop" becomes more prevalent every day), and leverage web searches and forums for debugging. Build a simple project iteratively, and add complexity as you go. Fix bugs as they occur, but also proactively educate yourself on the bugs that can arise so they are less likely to so. Don't try to learn everything at once, and don't expect your first application to do everything you want it to right away. Know that debugging sessions can be confusing and frustrating at first, but recognize they are an essential part of the programming experience. And don't hesitate to ask for help on Stack Overflow when you get stuck.

Most of all, have fun with the process, and welcome to the community!

As someone who has been coding and learning to code for about 30 years: If you know what you need to figure out, there are lots of approaches. (Documentation, web search, Stack Overflow, textbooks, etc.)

But if you don't know what you don't know, and you are looking at a very broad question like "How do I decide what web framework to use? What frameworks even exist?", I think asking AI is a good place to start.

For those kinds of questions, the previous state of the art was "find someone knowledgeable and get them to teach you", or "google around and hope someone has written something good about it (and that it's not secretly spam advertising their own framework)", or "post on Stack Overflow, and hope your question doesn't get closed as 'too broad'".

For asking very open-ended vague questions, trying to rapidly get up to speed in an area you know little about, such that you don't even know what you don't know, AI can be hard to beat. (Especially for areas like frontend development, which the AIs know pretty well.)

Basically, I am just answering the same as some people, but if you want to learn without AI, get into the documentation of your favorite language, library, or technology stack.

Documentation can sometimes get you out of doubt when some weird error occurs. You can also use Stack Overflow or even forums to find out when you have some of those weird errors.

Embrace autonomy, not dependency.

I think there are many "ways" for learning. It depends on your needs; do you need to learn a programming language? Do you want to learn game programming? Or game engines? Or a CP-SAT solver, like OR-Tools?

Learning is hard, and sometimes solutions someone share with you are not that good for your case. Just to say, I've learned programming in C/C++ in college, and after many years I've read K&R (which is a bible for me), but it was helpful just because I've learned some "more advanced" concepts from it, because I've already learned how to program doing exercises and studying slides that professor gave me.

Otherwise, to learn Godot, I watched many YouTube tutorials, and in the end I've learned much more reading documentation than from videos. I've studied how Spigot works, and in this case videos were the best (I still can't figure out how to navigate docs in Spigot by the way).

I personally suggest you to do the classical "trial and error". Search something for what you are studying and do a lot of practice. For example, now I'm reading The TeXbook, which is written very well, but I'm learning more doing the exercises it suggests than reading the same chapter 20 times, but I've learned more about how CUDA works reading 20 times the same chapter than doing it using cudaMalloc. Just try follow a path and fail; fail a lot. Once you failed many times, the good path is the only one you can take.

If you need to learn Go or a framework in particular, forget AI. I think AI is a great tool, but not for learning. I personally think AI is like a calculator. If you don't know how to do additions and subdivisions, you can survive because yeah, there is the calculator, but you won't ever learn how to do additions well until you do it by hand, fail and retry. Once you know how to do additions and multiplications by hand, use the calculator to do not waste your time when you need complex multiplications (just think when you need to elevate 9.12345 with a decimal number... just hell).

AI is the same thing. It's a great tool to have a basic idea or find a "basic" template, but you won't learn anything until you use it. If you already know Go and the framework you are using, it's fine using AI to get a basic idea about what you want to implement, but then you have to apply your skills of Go to create what you need. If you are stuck, just ask AI. It's fine, but it must be like the calculator; you use it only in the end and only if doing it by yourself is a obvious waste of time.

To conclude, I suggest you to learn what you need with books, and a lot of practice and documentation. Just find the way you need to learn. Once (and I mean, only once) you learned doing basic things with the tools you learned, ask AI if you are stuck or just need some boilerplate thing (like "generate me a basic HTML page with this title and subtitle").

What we learn to do, we learn by doing. — Thomas Jefferson

You can find similar quotes from many other historical figures.

Not having heard of it is not as good as having heard of it.

Having heard of it is not as good as having seen it.

Having seen it is not as good as knowing it.

Knowing it is not as good as putting it into practice.

— Xunzi, 3rd century B.C.E.

I think learning any professional skill requires two things:

1. Study
2. Practice.

Repeat as necessary. You read a little, you try it out, you read some more, you try more. Ask other experienced people to review your work. Study some of their work (in this case, code) and see what was successful and what wasn't.

I learned programming before AI, before Stack Overflow, before Google, even before the web. We learned by reading books and reference documentation. There were no web browsers. You read a physical book on the table next to your keyboard and tried the things you read in the book by typing them in. The time and physical repetition of typing (or even better, writing with a pen) has a proven effect on learning and retention. It's like your brain needs the time to cement the knowledge. The physical action of your fingers helps reinforce it too.

I was working in the computer lab in college, around 1986, and the computer center manager was passing by. He said, "I was going to recycle these, do you want them?" he was holding two bound volumes of every UNIX man page. All the commands, all the C functions, all the system calls. I said "yes!!" because my experience was reading a man page, clearing the screen, and getting into the text editor to try my code on one screen (there were no windows on those old terminals). Having a printed reference for the man pages to have next to me saved me a lot of time.

So I read the man pages, and I tried every command and every function. I wrote dozens of little practice programs to learn how to use what I read in the man pages. That time gave me the training I needed for a 35 year career as a software developer. Both the knowledge itself, and the habit of studying and practicing.

Making mistakes has underrated value as a teacher.

An expert is a person who has found out by his own painful experience all the mistakes that one can make in a very narrow field. — Niels Bohr

Give yourself permission to try things even though you aren't sure they'll work. If they don't work, take time to examine why they didn't work.

I don't believe there is any short-cut for this. People who try to learn by getting AI summaries of everything, or having someone tell them the "right way" to do something are missing a crucial part of growth. I worry about this a lot.

It's like learning to play a musical instrument. You don't listen to a piece of music once, get ChatGPT to tell you the "right" chords, and then suddenly sit down to a piano for the first time and instantly play that music as well as someone who has practiced it.

I recommend the following blog by Peter Norvig, who was an engineering leader at Google and Stanford. Even if you're not a beginner, it's worth reading his advice every few years as a reminder.

https://www.norvig.com/21-days.html

Asking what the "best" language or framework or platform or anything is irrelevant. Most applications can be implemented in almost any of the top 50 popular languages. Just pick one you like and try it. Later, pick a different language and try the same app. Think about how the project is different with each language. Or what habits of the second language can teach you about using the first language. Learn a new programming language every two years or so. The more languages you learn, the more insight you will have into the strengths and weaknesses of all the others.

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.

This question makes me feel 30 years older immediately. So there are already people who don't know that books, www, youtube exists? And that happened in just 3 years? How did you learn stuff in school?

Udemy, YouTube ... educational video services.

When I first started learning to program, I don't even start with any mainstream programming language. I still remember fondly the Mediachance Multimedia Builder (MMB), it was the first thing that I learned back in 2012. It's a software that lets you create an app mainly for "autorun" for CD and thumb drive. It offers a simple to use and WYSIWYG editor and close to no coding skill to build an app. But it has a scripting support to create more complicated logic. This were my first experience with writing code.

As time progress, I learned HTML and CSS with Microsoft FrontPage 2003, then Adobe Dreamweaver CS5. Back then jQuery was the SOTA library for creating web apps. I also learned a bit about PHP but never really liked it.

Then I started learning about Visual Basic in Microsoft Office (VBA) and then I stumbled upon Visual Basic 6.0 where I can create a more "proper program" so to say. Windows Forms was my new toy. VB6 was already outdated in 2015, and I stared exploring .NET Framework 4.0 and Visual Studio 2010 Express. Back then there was no VS Community Edition and .NET is still a proprietary, compared to .NET 10 now which is open source. Various websites such as Stackoverflow, CodeProject, VBForums, CodePlex (now gone), Planet Source Code (now gone), random blogs, and MSDN (now MS Learn) were my primary source of learning materials. I also liked O'Reilly books as it provides a more concrete example of how things are done from an expert point of view (compared to random blogs).

I still used VB.NET until I changed to C# in late 2017. Then I got my first job in 2019 and was quite shocked to learn that I were assigned to a team with NodeJS as the main framework as I don't have any experience with it. My previous experience with reading technical blogs and documentations proved to be invaluable for my career. It allows me to learn new stuff quickly and adapt to strange areas such as web development using React/Vue (crazy gibberish: JSX)

My way of learning:

1. Plan a project
2. Try stuff until it worked

I remember switching from framework to framework, library to library, language to language, database to database. I never completely finished the project, but the journey learning various language, framework, libraries, and databases is the most fun thing about learning to program.

I argue that it is harder to start learning programming now even with abundance of resources, because the technological advancement and AI have gone so far that it is hard to learn the basics to the current industry standard. It would take a huge amount of time and efforts to understand the nuances of why certain application use X or Y approach. I still struggle when changing job because the tech stack is constantly changing.

If you're feeling lost and overwhelmed with the amount of information you need to learn, you're not alone. All great programmers have gone through similar process. I think having a mentor would be the best way to learn. Keep up the good work.

Everyone learns differently. You have to know your own best style. Some people learn by slogging through the documentation. Some people learn by following tutorials. Some people learn by fetching some existing project and tracing through the code. It's up to you.

As a test - why did you ask this question here, and not consult an AI?

Because we're a better resource that can comprehend the question, and the bits that weren't asked. The collective-We can provide relevant context whereas an AI is just answering with "whichever word comes next".

Would an AI have flipped it over with a counter-example like this ? No.

A lot of good answers already, but one thing that I believe deserves more emphasis: problem decomposition. When learning, when developing software, when solving any non trivial problem, part of what we do is taking a large problem, breaking it down into smaller pieces, prioritizing and identifying which piece must come first/last due to dependencies, which things to abstract away, accept on blind faith then come back later to with stronger foundations, etc.

If you can develop this early, it means that you can more effectively learn each small thing, connect it to the big picture, etc - which is something that AI sorta does but not always consistently or coherently (especially over multiple sessions). That sort of organization of thoughts, concepts, and knowledge is something that you as a learner can do much better for yourself - if you are prepared to do it, and especially if you have motivating projects you've decomposed into subproblems.

"After that, I build on top of it" - - have you tried taking things away instead? One interesting way to learn is to take a working project and try to extract only the bits you want. That forces you to a) understand the code you've copied b) think about what you're trying to build c) practice problem decomposition d) sift through a bunch of code and think "what is that for? I don't need this". The last benefit is quite useful because often you don't need (or want) a lot of the bells and whistles which experienced engineers build into projects but seeing them once will help your brain go click when your requirements change in a year or two and suddenly you need to solve a problem which is addressed by a particular bell or whistle.

To answer your main question: there are lots of example projects scattered all over the place. Sometimes it is a bit of a pain finding exactly what you want but once you have it then you're set.

(I think it is probably reasonable to use AI to shortcut this search process)

There are a bunch of different (non-AI) ways to learn things and solve problems:

1. You can read a book, take a course, do a tutorial or read documentation to learn the basics. I put this one first because it should be the starting point of learning things (at least after you've figured out what you want to learn).

2. There are blog posts comparing different framework, languages or whatever other options one have during development.

3. There are sample projects and code online.

   • Documentation often has code samples showing how to use their tools. Places like Stack Overflow have code samples for solving specific problems. These 2 help construct the fundamental building blocks of whatever you're trying to make.

   • You can also get more complete projects through Google searches. There may also be easily-searchable repositories for projects using whichever language or framework (GitHub is obviously one of the biggest repositories, but I haven't used it to try to find specific projects).

4. You can get someone to explain something to you one-on-one, to fill in some blanks or extend your knowledge.

LLMs can be used as an alternative to points 2-4. For a lot of this (particularly points 2 and 3), they are arguably often an inferior alternative - they can get important details wrong, and they just copy the end result of a lot of people's work.

It's probably a rather bad idea to use LLMs as an alternative for point 1. It'll be an uphill battle to just repeatedly ask it explain one thing or another without it being structured learning. At best, you could probably prompt it to write as a book or course or tutorial or documentation. But saving yourself a 2-minute Google search at the cost of not knowing which of it is right doesn't seem worth it. It could make more sense to use it as a supplement to those things: if there's some part of a book you don't understand, you could ask an LLM to explain it. If there's some part of a course you don't understand, it might often make more sense to ask the teacher (if able), so they know that some part of their teaching may be unclear and they can improve on it in future lessons.

LLMs can of course also be used to write code that you already (at least broadly) know how to write, rather than as a learning tool. There are more and less responsible ways to do so.

Good start is to read documentation and try provided tutorials, follow tags related to technologies you are using or want to learn at StackOverflow to get knowledge about things people are struggling with and how to solve those. It helps with understanding the design side of development too. GitHub is good source of code samples or ready projects to go through and try to understand how things are done by cloning, running and debugging it. GitHub also has a lot of awesome lists, that are referencing certain topics(just search term "awesome" then click repositories in left panel). Making a bucket of blogs that are focusing on technologies you are interested in is also good thing to make and find time to read new posts. There are also people posting tips and tricks on social networks or streaming on YouTube live coding sessions. There are sites for education purposes, that are free. There are also free courses.

For starters:

Developer Roadmaps

GitHub: sindresorhus/awesome

GitHub: DovAmir/awesome-design-patterns

Hope it helps. Happy coding and learning!

how would you get started on that kind of project

By starting small, learning the basics, and gradually developing an understanding of what tools/frameworks are appropriate for various situations.

Do you really expect to start using a new language/tool/framework and fully understand it immediately? That's not how "learning" works.