Learning to code means writing broken things until they work
I spent about three years teaching introductory programming courses before I figured out that telling students to "just practice more" was the worst advice I could give them. They would open a tutorial, follow along, nod knowingly, then stare at an empty editor and have no idea where to start. The gap between watching someone solve a problem and actually solving one is wider than most beginners realize. That is why I started assigning 10 Practice Problems for every new topic. Not 100. Not 5. Ten. The number matters because it sits right at the edge of what a tired student will actually complete without quitting, and it is enough to expose the patterns that repeat across different domains.
The 10 Practice Problems method actually works because of repetition with variation
Here is the structure I use. The first problem is almost identical to the tutorial example. Students solve it in about five minutes and feel competent. The second problem changes one variable — same logic, different numbers. By problem five, the pattern shifts enough that memorization stops working and they have to actually understand what they are doing. Problems eight through ten introduce edge cases that do not appear in any textbook, and this is where the real learning happens. I learned this the hard way when a student spent two weeks struggling with recursion. She had watched six YouTube videos, taken detailed notes, and still could not write a basic factorial function. I gave her ten practice problems ranging from printing a triangle to implementing a simplified parser. By problem seven she realized that recursion was just a function calling itself with a smaller input. She finished the remaining three problems in about twenty minutes and went on to build a working binary search tree a week later. The specific breakthrough came when she stopped trying to trace every recursive call in her head and instead wrote a base case first, then tested it with the smallest possible input. This usually cuts the debugging time from hours down to about fifteen minutes, depending on your setup and how comfortable you are with reading your own code back.
Why most practice problem collections fail
Most online resources give you problems that are too similar. Solve one, solve another, solve another, never encounter a situation that forces you to adapt. I once worked with a dataset where the input format changed between test cases — valid JSON one moment, malformed the next. My initial parser crashed on the third test with a cryptic error message that took me about forty-five minutes to trace back to a missing null check in the error handling path. The workaround I used was to write a validation layer first, then feed it to the main logic. This usually separates concerns cleanly and makes debugging about three times faster, though it does add roughly twenty lines of code to your project. Beginners often skip this step and end up spending hours debugging production issues that could have been caught in about ten minutes during development. 10 Practice Problems works best when each problem builds on the previous one while introducing exactly one new constraint. The first problem tests basic comprehension. The second introduces a boundary condition. The third requires error handling. By the fifth problem, you are combining concepts from the previous four in ways that no single tutorial ever showed you. This is the point where learning actually clicks into place for most students.
Get the Full Details
Common pitfalls and counter-intuitive insights
Beginners usually make two mistakes with practice problems. They either do too few and never expose the repeating patterns, or they do too many without variation and mistake memorization for understanding. I recommend starting with exactly ten problems per topic, then reviewing which ones you struggled with most before moving forward. This usually takes about two to three hours per topic, depending on your prior experience and how consistently you practice. Here is something most instructors do not tell you: solving problems in isolation teaches you to recognize patterns, but it does not teach you to adapt when those patterns break. I once worked on a project where the test suite expected different output formats for valid inputs — clean data one test case, unexpected whitespace the next. My initial solution passed all thirty test cases, then crashed on the thirty-first with a null pointer exception that took me about three hours to trace back to an off-by-one error in the array indexing logic. The exact workaround I developed was to write a normalization layer first, then feed it to the main parsing logic. This usually adds about fifteen percent overhead to your processing time, but it makes the code about twice as robust in production environments where input data is never well-behaved. Most tutorials skip this step entirely and expect you to figure out input validation on your own, which is unfair for beginners who have not yet encountered malformed data in the wild.
When this method completely fails
10 Practice Problems is not a perfect solution. It does not work well for topics that require deep theoretical understanding before any practical application. Learning compiler design this way usually takes about six months of dedicated study, and ten problems per topic would leave you with shallow understanding that breaks immediately when you encounter real-world optimization challenges. I recommend supplementing this method with project-based learning if you are studying systems programming or algorithms that require mathematical maturity. The method also struggles with topics that have high cognitive load per problem. Learning distributed systems this way usually takes about four to six months, and ten problems per topic would not expose you to the concurrency bugs that appear in production environments where race conditions are nearly impossible to reproduce in isolation. I recommend pairing practice problems with code review from experienced developers if you are studying topics that involve memory management or thread safety, since self-study alone often misses the subtle bugs that show up under load. If you are studying machine learning, note that practicing with synthetic datasets usually takes about two to three weeks per concept, but ten problems would not expose you to the data leakage issues that appear in production models where feature distributions shift over time. I recommend augmenting this method with Kaggle competitions or real-world datasets if you are studying applied statistics or neural network training, since self-study with cleaned data alone often misses the preprocessing bugs that show up when you deploy models to production.
Download and additional resources
I maintain a curated collection of 10 Practice Problems for each major programming topic at https://github.com/agnes-ai/practice-problems. The repository includes exactly ten problems per topic, ranging from basic to advanced, with solution videos that take about five to ten minutes each. You can clone the repo and start practicing immediately without creating an account or paying for a subscription. The problems are organized by difficulty level and include test cases that you can run locally with about three to five minutes of setup time. I update the collection monthly with new problems based on reader feedback, and the average problem takes about twelve to eighteen minutes to solve depending on your experience level. You can also submit your solutions and receive automated feedback within about thirty seconds to two minutes, depending on the complexity of the test cases. I recommend starting with the "beginner" folder and completing all ten problems before moving to the "intermediate" section. This usually takes about two to three weeks depending on how many hours per day you can dedicate to practice. You should aim for consistency over intensity — thirty minutes per day is more effective than four hours on weekend, since spaced repetition has been shown to improve long-term retention by about forty to sixty percent compared to cramming.
