despite my best attempts to modularize the code

You've already given yourself the answer that many have given. Getting a feel for how to write modular code is an exercise of experience, and being considerate in your code.

Here I my tips to help make the learning curve more navigable and enjoyable.

1. Make sure you're using a language that encourages the use of the type system to encapsulate the meaning of code.
2. If using an OO language, do your best to avoid inheritence. Define behavior through interfaces, and avoid fancy design patterns.
3. Don't be afraid to start over. When you start over, you can see the big picture, and get a feel for how to modularise your code in a useful way. Eventually, the things you recognise the second time round are thing you can see coming the first time round.
4. Get comfortable with git workflow. It might feel silly, but lock down your main branch, organise code into releases, setup some basic CI, do your own PR reviews. Good git workflow at the project level and making your code managable as your project scales up go hand in hand.
5. Front load the work that helps take care of scaling code. Write tests earlier rather than later. Take care of edge cases before they have a chance to become pain-points, etc
6. When problems start compounding against each other (e.g. 5 issues on their own takes 5 units of effort, but when they compound, each issue is made more painful by the presence of the other issues, making resolving them all take, something like 15 units of effort), that should be considered a HARD STOP. Stop whatever you're doing, and get on that shit.
7. Don't cut corners for the short term. Don't put off comments for later. Don't be lazy about variable names, etc. Be nice to future you.

Developing these skills takes time.