Why Programming Isn’t Just About Problem-Solving

The idea that programming is just about solving problems has always bothered me. It sounds reasonable at first—after all, the code you write is a solution to a problem. Code is a recipe that makes a cake. Code can literally solve a puzzle and can literally solve for x. But reducing programming to just problem-solving is too broad to be useful, especially for beginners.

It’s a common piece of advice given in the context of career development: “Programming is just problem-solving.” But what does that even mean? What are you supposed to do with that information?

It’s a hand-wavy, vague generalization, and the problem with generalizations is that they rarely help people who are just starting out. Before you can even begin solving problems, you first have to learn the fundamentals. You have to write a lot of code. Telling a beginner that programming is all about problem-solving is like telling an apprentice carpenter to focus on “solving problems” rather than learning to use a hammer. That’s not how learning works. Before you can see the forest, you have to work on some trees.

The Myth of “Problem-Solving” as a Skill

It wasn’t until I stumbled upon Scott H. Young’s post on Cognitive Load that I understood why this idea of problem-solving as the meta-skill of programming felt wrong.

Problem-solving isn’t really a skill. Or at least, not in the way most people think. The way we get good at solving problems is by having:

1. Knowledge that assists in solving the problem (domain-specific knowledge).
2. Automatic procedural components that help in solving problems (patterns and techniques we’ve learned).

There’s no universal, all-purpose “problem-solving” method that works across every domain. Heuristics exist, but they’re completely overshadowed by the importance of having learned patterns in memory. This explains why expertise is highly domain-specific and why “transfer” (applying skills from one domain to another) is so difficult.

To solve a programming challenge, you need programming knowledge. You need to know syntax, logic, and built-in language features. Sherlock Holmes, with all his logical reasoning, might be able to conceptualize a solution for FizzBuzz, but without knowing how to write in a programming language, he wouldn’t be able to actually code it. He would need to know what an if statement is and what the modulo (%) operator does.

This is why saying “programming is just problem-solving” is misleading. Everyone is good at solving some type of problem—crossword puzzles, Sudoku, chess, fixing cars, making coffee. But these skills don’t necessarily transfer to programming. The skill isn’t problem-solving. The skill is being good at chess. Or being good at fixing cars. Or being good at writing JavaScript.

You might be a Sudoku master, but that’s not going to help you construct an undirected graph in code.

You don’t get better at “problem-solving” in general. You get better at specific domains by studying and practicing the knowledge relevant to that domain.

The Skills That Actually Matter

So if problem-solving isn’t the core skill of programming, what is? What skills actually help you learn to program and, eventually, solve problems in programming? Here are a few:

1. Being Comfortable with Frustration

“The programmer personality is someone who has the ability to derive a tremendous sense of joy from an incredibly small moment of success.”
— Coders, Clive Thompson

Computers are stupid and pedantic. They care about details—major and minor. They will frustrate you. The sooner you accept this, the better. The trick is to take a Zen approach. Don’t fight the frustration. Let it rise, acknowledge it, and move on. Eventually, you’ll find that missing semicolon or the undefined variable.

2. The Ability to Think Abstractly

If there's one ability that’s the closest to a general problem-solving skill and certainly helps with learning to code, it’s the ability to think abstractly. Programming isn’t just about writing step-by-step instructions—it requires recognizing patterns, understanding how different parts of a system interact, and thinking beyond immediate details. Abstract thinking helps you see a for loop as more than just iteration, recognize common problem-solving patterns, and design scalable solutions. The good news? It’s a skill you can develop by working through coding challenges, learning design patterns, and practicing breaking down complex ideas into simpler, reusable components.

3. Patience and the Ability to Take Things Slowly

Learning to program takes time. Whatever number of months or years you think it’ll take, triple it. Hofstadter’s Law states that everything takes longer than you expect, even when you take into account Hofstadter’s Law. See also: recursion.

4. Being a Good Reader

Most people skim through documentation. They don’t read actively. But reading documentation carefully can save you hours of debugging.

Many great programmers are voracious readers. This skill also ties into patience—you have to be willing to sit down and thoroughly read something before jumping in.

5. Being Decent at Writing

You don’t need to write like Hemingway, but you do need to be able to put into words what you’re trying to tell a computer to do. If you can’t explain in plain English (or your native language) what your code is supposed to do, you probably don’t fully understand it.

6. Math Literacy

You don’t need to be a mathematician, but you do need to be math literate. Your mileage may vary—if you want to do game development, you’ll need geometry and physics. For mobile or desktop apps, some math will creep in. Even in web development, you’ll eventually run into scenarios where math knowledge helps.

Fight the math phobia your bad teachers instilled in you. Go watch some Khan Academy videos and get caught up.

7. Enjoying Puzzles and Games

It’s no surprise that many programmers love puzzles and games. Breaking things apart, thinking logically, and putting things into discrete steps—all of these are crucial in programming. I have yet to meet a programmer who hates puzzles or games.

8. Touch-Typing

Knowing your way around your keyboard is more important than it seems. Touch-typing makes you faster, more efficient, and reduces errors when coding. You don’t have to be a Neovim guru, but at the very least, you should know where the backtick key is.

Final Thoughts

There are probably more skills that help with learning to code, but these are the ones that have the biggest impact. So:

• Embrace frustration.
• Think abstractly.
• Be patient.
• Take your time reading documentation.
• Learn to explain things clearly.
• Brush up on your math.
• Play some games and solve some puzzles.
• And for the love of all things holy, learn to touch-type.

If you think I left something off the list—or just enjoyed this post—drop me a comment and hit that subscribe button.