How often have you thought that software developers and artists are quite alike to each other? At first thought, it might seem that both these professions are in no way similar but a deeper glance will tell you that both of them are “makers” at the end of the day. Even though they use different mediums to communicate their craft to the audience, the underlying ideologies have a lot in common.

You learn to draw or paint by doing it. The same is for writing code too. Most often you can’t learn software development by taking up courses. You can only learn by doing it and getting your hands dirty with it. Another aspect that makes painting and writing code quite alike is the fact that both of them depend largely on past works to gain inspiration to make new/better art or software.

Here are some lessons which find parallelism in the life of both developer and painter and can be used to achieve individuals goals in particular fields of interest and expertise :

Ignoring details initially: It’s important that we ignore details initially. While focusing on a single block of code it is obvious that we forget about the big picture. In painting is said that “ A well-formed object even with some imperfections is always better than one with lots of details but which lacks a solid base or grouped form”

Rather than focusing on details like unnecessary dependencies, premature optimization, and complex abstraction, a developer should keep in mind the final outcome and try to come out with a “just working” solution initially.

Donald Knuth, a well-known computer scientist in his book “ The Art of Computer Programming” talks about premature optimization. Premature optimization is spending a major fraction of your time doing something that may be unimportant or may not be really required for the first time. Here’s the real quote from the book

“The real problem is that programmers have spent far too much time worrying about efficiency in the wrong places and at the wrong times; premature optimization is the root of all evil (or at least most of it) in programming.”

Importance of iteration: The importance of iteration in the software development life cycle isn’t alien to developers. The world of art also practices iteration and emphasizes its importance. Iteration is about refining what you build. Paintings are created by gradual refinement.

Before making the final craft an artist tries to sketch it out on a piece of paper. At times it is possible that the final piece is quite deviated from what was initially planned. A good block code is one whose specification can be changed on the fly. This is where the question of choosing the right programming language comes to play. A programming language should be like oil paint i.e it should give you enough freedom to make changes to your codebase on the fly.

Doing your own art: Painters usually avoid using straight from the bottle colors. It is because what shade worked for someone might not work for you. You have all the right to mix the colors of your choice since it is your art.

Similarly, as a developer, you have the freedom to sculpture your code block. It is perfectly okay and acceptable as long as you know why you are doing something ( you should have a strong logic backing it ).


Painters start from scratch usually. They usually learn from examples. A museum is a kind of reference library for any artist. Painters usually try to reproduce some previous works of their great masters. In the process, either consciously or unconsciously they create original works of their own. The same goes for developers too. You might fork a GitHub repository or use someone’s else source code and build on it but eventually, with time, you would have given shape to a code-base on your own.

Creativity and the importance of nothingness: Painters learn how to paint by doing it. The only way to learn most of the art/science is by getting your hands dirty early on. It all begins from zero. Pick any masterpiece by a well-acclaimed artist, the first copy of the art would be a rough sketch on a piece of paper.

Coding or software development too demands first thinking in and out about the problem at hand and working it out either in your mind or on paper before writing a single line of code. This where the question of “documentation” comes into play. Documenting why you are picking up a particular software architecture/module/component is not just for anyone who reads your code but it is for your own good. It helps you to have a clear idea and road-map about the software you are going to write.

Nothingness or being unaware of what needs to be done has a lot of hidden importance. It catalyzes your creativity and forces you to think about all possible outcomes or solutions.

Have a great grasp of fundamentals: As a developer, you might find various dev tools and newer technologies available at your end for use every other day.

Any good artists start by exploring and sketching simple shapes and builds a strong foundation. He/She builds upon these foundations to give shape to complex objects. Complex objects are after all nothing but well-formed groups of simple primitives.

This is true also for software development. It is very important to have a good grasp over basic fundamental principles ( like OOPs concepts of polymorphism, inheritance, abstraction, and encapsulation ) rather than picking any fancy framework which is currently trending. Emphasis should be on what concept you are trying to implement and what underlying research is based on.

Empathy: Most art is intended for the audience. You win your audience’s heart only when you put yourselves in their shoes and see things from the user’s point of view. Hence, empathy is a must for both developers as well as painters. Seeing things from someone’s else point of view doesn’t mean that you suppress your own ideas or views. It’s more about finding what your audience wants.

If you have closely noticed, most paintings are on people, that is because what interests humans the most are other humans. Empathy is probably one single character trait that differentiates a good developer from a developer. You might be a smart developer but your egoism becomes a bottleneck when the question of empathy comes into play.

If you practice empathy and learn to see things from the user's viewpoint, then designing good software becomes a cakewalk ( not really though). Empathy develops when you interact with your user often and take the seat of the listener. One way to tell people how good they are empathy is to watch them explain a technical term to a layman without any technical background. Good software isn’t the one that is fast or machine-understandable but one that is easily human-understandable.

Recognize patterns: For example, take a look at the picture below. At first, it might look like a herculean task for a novice to figure out where to start from but with a closer look, you can see that these repetitive patterns or objects. Identifying underlying patterns is very essential for an artist.

René Magritte — Golconde, 1953

Similarly, for a designer/developer, it is important to study and an idea about design patterns. Knowledge along with experience will make it easier for you to correctly detect and apply the best design practices at the right places. In turn, this will make your code more robust and easier to comprehend.

Importance of Collaboration: Most of the world-class art are works of multiple hands. A good example is a collaboration of Andy Warhol and Jean-Michel Basquiat for over 6 years during which they produced some of their best pieces which are still appreciated in the art world.

Olympic Rings, Andy Warhol, and Jean-Michel Basquiat

But painters who worked together never worked on the same part. Similarly, when you team up with someone as a developer it is important to divide your work. Not only does it implies ownership and responsibility but it also makes it easier for the team to design good software since one person focuses on one module only. It is important not to neglect the importance of wiring and proper interfaces which would help to finally combine the modules together in the end.

Sharp eye for details: Artists have an eye for detail. Their visionary senses are sharp enough to notice a small stroke or shade which doesn’t look good. The same goes for developers too. They should pay attention to detail. Writing beautiful code is as important as writing good and working code. By beautiful, it means a code that is easily readable and understood.

Code is after all clay. To mold it into something of value and worth of appreciation you require inspiration, creativity, thoughtfulness, and skill. As Paul Graham in his essay Hackers and Painters says “When people walk by the portrait of Ginevra de Benci, their attention is often immediately arrested by it, even before they look at the label and notice that it says Leonardo da Vinci. All those unseen details combine to produce something that’s just stunning, like a thousand barely audible voices all singing in tune”. What it means is that the one who writes codes or paints needs to be relentless in his efforts to give the perfect shape to the finer things.

I write about all things product and startups. Product person at heart. Hobbyist Developer.