I'll start this post with a quote:
Good developers are good problem solvers. They turn each task into a series of problems they have to solve. They don't necessarily know how to solve them in advance, but they have their toolbox of approaches, shortcuts and other tricks that lead to the solution. I have outlined one such set of steps for identifying problems, but you can't easily formalize the problem-solving approach.
But is really turning a task into a set of problems a good idea? Programming can be seen as a creative exercise, rather than a problem solving one - you think, you ponder, you deliberate, then you make something out of nothing and it's beautiful, because it works. And sometimes programming is that, but that is almost always interrupted by a series of problems that stop you from getting the task completed. That process is best visualized with the following short video:
That's because most things in software break. They either break because there are unknowns, or because of a lot of unsuspected edge cases, or because the abstraction that we use leaks, or because the tools that we use are poorly documented or have poor APIs/UIs, or simply because of bugs. Or in many cases - all of the above.
So inevitably, we have to learn to solve problems. And solving them quickly and properly is in fact, one might argue, the most important skill when doing software. One should learn, though, not to just patch things up with duct tape, but to come up with the best possible solution with the constraints at hand. The library that you are using is missing a feature you really need? Ideally, you should propose the feature and wait for it to be implemented. Too often that's not an option. Quick and dirty fix - copy-paste a bunch of code. Proper, elegant solution - use design patterns to adapt the library to your needs, or come up with a generic (but not time-wasting) way of patching libraries. Or there's a memory leak? Just launch a bigger instance? No. Spend a week live-profiling the application? To slow. Figure out how to simulate the leaking scenario in a local setup and fix it in a day? Sounds ideal, but it's not trivial.
Sometimes there are not too many problems and development goes smoothly. Then the good problem solver identifies problems proactively - this implementation is slow, this is too memory-consuming, this is overcomplicated and should be refactored. And these can (and should) be small steps that don't interfere with the development process, leaving you 2 days in deep refactoring for no apparent reason. The skill is to know the limit between gradual improvement and spotting problems before they occur, and wasting time in problems that don't exist or you'll never hit.
And finally, solving problems is not a solo exercise. In fact, I think one of the most important aspects of problem-solving is answering questions. If you want to be a good developer, you have to answer the questions of others. Your colleagues in most cases, but sometimes - total strangers on Stackoverflow. I myself found that answering StackOverflow questions actually turned me into a better problem solver - I could solve others problems in a limited time, with limited information. So in many cases, I was the go-to person on the team when a problem arises, even though I wasn't the most senior or the most familiar with the project. But one could reasonably expect that I'll be able to figure out a proper solution quickly. And then the loop goes on - you answer more questions and get better at problem-solving, and so on, and so forth. By the way, we shouldn't assume we are good unless we are able to solve others' problems in addition to ours.
Problem-solving is a transferable skill. We might not be developers forever, but our approach to problems, the tenacity in fixing them, and the determination to get things done properly, is useful in many contexts. You could, in fact, view each task, not just programming ones, as a problem-solving exercise. And having the confidence that you can fix it, even though you have never encountered it before, is often priceless.
What's my ultimate point? We should see ourselves as problem solvers and constantly improve our problem-solving toolbox. Which, among other things, includes helping others. Otherwise, we are tied to our knowledge of a particular technology or stack, and that's frankly boring.