Between Curiosity and Consistency: The First 100 Steps Toward 10,000 Problems

Created: June 1, 2026 Last Updated: June 1, 2026

The graduate student who wanted to solve 10,000 real analysis problems and the fictional archer who wanted to shoot 10,000 arrows

The number 10,000 seems to hold a special place in stories about mastery, discipline, and long-term commitment.

One of my favorite anime, Tsurune, features a conversation where the character Takigawa Masaki talks about shooting 100 arrows a day for 100 days—a total of 10,000 arrows. Recently, I came across two videos on the YouTube channel Struggling Grad Student: 10,000 Problems in Analysis and So… how are those 10,000 problems coming along?. Different disciplines, but the same underlying idea: mastery is built through consistent practice over a long period of time.

Those stories inspired me to begin a similar journey of my own.

When I started thinking about what kind of problems I wanted to solve, the answer came naturally: Computer Science.

My interest in Computer Science began in high school in 2014. Over the years, what started as a school subject gradually expanded into an entire field of study and work. I explored topics such as Data Structures and Algorithms, Operating Systems, and Database Management Systems through self-study and undergraduate coursework. Later, Andrew Ng’s Machine Learning lectures introduced me to the world of machine learning, ultimately influencing both my master’s studies and my professional interests.

Today, Artificial Intelligence stands as one of the most influential and rapidly evolving areas of technology, especially with the rise of Generative AI. Yet, the deeper I explore this field, the more I realize that advanced models cannot exist in isolation. Building real-world AI systems requires far more than understanding algorithms—it demands strong foundations in computing systems, software engineering, data management, and problem-solving.

As I prepare for the next stage of my career as an engineer, I want to bridge the gap between abstract theory and production-ready systems. This challenge is my way of returning to the fundamentals while cultivating the consistency, adaptability, and technical depth needed to build intelligent systems at scale.

Why 100 and not 10,000?

“A journey of a thousand miles begins with a single step.”

— Lao Tzu

This has always been one of my favorite sayings.

The idea of solving 10,000 problems is exciting, but it also feels overwhelming. As someone who has often struggled with consistency, I know that ambitious goals alone are not enough. Progress requires a process that can be sustained day after day.

So instead of focusing on 10,000 problems, I am starting with a much smaller milestone: 100 problems.

The goal of these first 100 problems is not to achieve mastery. It is to build the habit of showing up regularly, develop the patience to work through difficult questions, and learn how to stay consistent even when progress feels slow.

If I can solve 100 problems consistently, then perhaps the next 100—and eventually the next 1,000—will become possible.

What does a “question” mean?

Defining a “question” in Computer Science is not as straightforward as it might be in mathematics.

Many mathematical problems are well-defined and have clearly verifiable solutions. Computer Science, on the other hand, spans a broad range of activities: mathematical reasoning, software implementation, system design, experimentation, and empirical analysis. Problems often have multiple valid solutions, and many resources do not provide official answers or solution guides.

Because of this, I need a practical definition of what counts as a question for this journey.

For now, I will count the following as valid problem types:

Mathematical proofs or derivations
Working code implementations (e.g., implementing stochastic gradient descent from scratch or solving algorithmic programming problems)
System design and architectural proposals
Experiments and empirical analyses (e.g., model training, evaluation studies, benchmarking, and data analysis projects)

Not all questions will require the same amount of effort. Some may take less than an hour, while others may span multiple days. For the purposes of this challenge, each self-contained problem, implementation, design exercise, or experiment will count as a single question.

This definition will likely evolve as the journey progresses.

How do I plan to keep track of the problems I solve?

The Dashboard

A dashboard tracking Problems 1–100 will be maintained on this site. Each entry will contain:

The problem statement
Key takeaways
Relevant tags and categories
Links to detailed notes

The goal is to create both a public record of progress and a searchable index of what I learn along the way.

Onwards to Season 1 and the first 100 problems

The road to 10,000 problems is long.

The road to the first 100 is much shorter—but it is where the journey begins.

More importantly, this challenge is not solely about reaching a number. My primary goal is to explore different areas of Computer Science and strengthen my understanding of the field as a whole. Some weeks I may focus on algorithms, while others may be spent studying machine learning, systems, databases, mathematics, or software engineering.

The problems themselves will vary in both topic and difficulty. Easy questions will help build consistency. Difficult questions will build patience. Together, they will form the foundation for long-term growth.

So this is Season 1.

Problem 1 awaits.