I was always overwhelmed by very large projects also, like the ones you find on SourceForge or GitHub. I wondered how anyone, or even a team, could understand what was happening across 10's or 100's of files, with thousands and thousands of lines of code.

No one does. At least initially.

Projects are organic things. What starts off as a really simple idea, can quickly expand into a massive piece of work. This is, I think, the main reason for iterative development instead of the classic waterfall approach.

Think of building a car. While it looks fairly simple from the outside, delving even a small way in you discover that there are a huge number of considerations, trade-offs, and innocent cases that need to be handled.

Example:

In the case of a semi-large project, it often starts out small. "I want to build a cache server". So you spend a few days hacking away, and arrive at something that works, but could be improved dramatically. So you add the concept of threading.

Then you run into concurrency issues due to that threading. So you fix by changing to concurrent data structures.

Now the the process has slowed down. So you change the concurrent data structures to regular ones, but provide locking mechanisms for synchronization.

Everything seems to be running fine, except users start to complain that operations are not atomic, and data is being corrupted.

So you add in some classic atomic operations, like increment and save. This works, and your users are happy. But someone opens a ticket asking if it's possible to do list operations.

So you spend a week or two building that feature in. At about this time, a friend decides to help you. You work on it together, complete, and release it.

Two tickets open. There's a bug in the list processing, and there are some rare cases that are deadlocking.

Your friend works on the list processing bug, while you tackle deadlocking. You realize that a fairly significant re-write to atomic operations needs to occur.

... and so it goes.

This seems fairly typical of how a project grows. 10 or so files have just grown to 20 in a couple of weeks. New features are added that weren't apart of the original plan. Convoluted bug-fixes are added that grow the code unnaturally large.

My advice:

Don't become overwhelmed. If you have an idea, implement pieces of functionality. If it's worth pursuing after that, add bit by bit. Let your project grow naturally.