Where two organisms interact with one another, and both benefit equally.
Symbiosis is a part of life, and it has been crucial to the success of many creatures (not just humans) for many years.
For example, let’s talk about the oxpecker and the zebra.
In the wild, the oxpecker (a bird) will reside on a zebra’s back, and it will eat ticks off their body. The oxpecker gets a meal and the zebra loses the parasites.
That’s a symbiotic relationship. When both individuals are benefiting from each other’s interactions.
Now, what does this have to do with learning to code or design? Good question, and we’ll get to that.
All too often I see people discussing/arguing about how designers should learn to code and developers should learn design theory. I’m not on either side of the argument, but I’d like to highlight the benefits and drawbacks of each option. Essentially I want to highlight the opportunity cost of learning to code as a designer.
Benefits of learning to code
Coding is a world of its own. I have been coding (at a professional standard) for a few years now, but I started my journey around seven or eight years ago. I now focus on front-end web development, but I have worked on projects involving databases and backend functionality too.
What this has given me is an oversight of the level of effort and difficulty of implementing certain design decisions.
For example, if - as a designer - I wanted to suggest we develop an advanced piece of map input which lets the user drag around a pin, pops up nearby cafés on the map, and allows a user to drag some cafés into their favourites, I would know this is a complex piece of functionality and would take at least a few weeks to get right.
Therefore, if I knew the project was on a tighter schedule, and we only had a week, maybe I would consider suggesting a simpler input, and mentioning the map functionality for a future development sprint.
Having this understanding for difficulty and timescales helps avoid conflicts with developers who may be overwhelmed by what is being asked for in a tight timeline.
In addition, if I suggest something I know should take relatively little effort and it gets pushed back, I have enough understanding of the work involved that I could question the decision. Maybe the suggestion was not properly understood, or got lost in translation.
Learning to code - even if it’s mainly the basics, can help you (and your colleagues) communicate better via a shared language.
An integral part of any design process is understanding constraints and working out how to get around them. However, with no knowledge of code you will be unaware of the different constraints each platform you are designing for will have. This could seriously impact your design process, and most likely slow it down.
For example, if you were designing a number of email templates for a company, you might be tempted to include a beautiful, complex layout and some nice interactivity.
However, if you know how difficult it is to create email templates from scratch (seriously, why is it still this hard?), you might choose to go for a simpler layout. Without the knowledge of this constraint, you’d likely design a beautiful email template, only to be knocked back by the person developing it and have to start over again. This wastes a lot of time for both you and the developer.
Solving common problems
As a designer, you’ll likely be focusing your learning on the front-end, as it’s a lateral move into the development world from design.
Understanding the front-end code - which styles the application or website - allows you to solve common issues that may arise.
For example, imagine you are working with a full-stack developer who prefers working on the back-end functionality more than perfecting the front-end. This may lead to a few inaccuracies between your designs and the final product.
Let’s say one of the inaccuracies is that the spacing between different sections is too little. With knowledge of HTML and CSS, you would probably be able to spot a problem in the code for padding or margin, and suggest a fix to the developer (or if you have access, fix it yourself).
This knowledge would enable you to quickly pinpoint a problem, and therefore the solution could be realised sooner.
Collaboration and language
One pain-point I’ve noticed when working between design and development teams is that the language used to describe a problem can vary.
A project I worked on in a past role used a document which provided terms and their definition to help everyone use consistent and unambiguous language. This began to get quite verbose, and let’s be honest, nobody is going to re-read the document before a meeting or quick conversation.
Learning to code - even if it’s mainly the basics, can therefore help you (and your colleagues) communicate better via a shared language.
With more precise and accurate terminology in your toolbelt, you could describe issues with better precision, suggest changes, avoid misunderstandings, and generally communicate more efficiently.
We’ve discussed the benefits of learning to code, however it’s not a one-sided argument and there are also some drawbacks to consider. Let's dig into those.
Drawbacks of learning to code
Learning to code takes time - there is no shortcut, no easy way out and no way to just read a book and know how it's done.
There are a lot of courses out there that make big claims, like you'll learn to code in a week. Personally, I highly doubt these claims, because there is such a wide range of languages, devices and platforms in the coding world. If you do find a course that teaches you everything in a week though let me know, I’ll try to get a refund on my £40k degree.
The best way to become good at coding is to constantly train yourself, like you would at a gym. A few days or weeks off and you're rusty again (believe me, I've had a few holidays and come back to coding like "what am I doing again?").
My point is: learning to code at any sort of helpful level will take a significant amount of time. As a designer, that time could be spent elsewhere.
For example, you could choose to improve your accessible design skills, ensuring any design you pass along is already meeting accessibility guidelines (like those by WCAG).
You could also learn how to use a prototyping tool instead, giving you the possibility to create complex interactions that help better convey your desired designs and ideas to developers. These interactions could take you far longer to mock up with your new coding skills.
So, there is an opportunity cost of learning to code. You are sacrificing weeks of time that could be dedicated to honing your skills in another way.
This isn't to say that you shouldn't learn to code. This is just highlighting that it's not the only thing to invest your time into in order to improve career prospects and team efficiency.
Learning to code at any sort of helpful level will take a significant amount of time. As a designer, that time could be spent elsewhere.
Thinking inside the div tag box
Often when I work with great designers, they produce experiences and interactions that I wouldn't have ever dreamt of, because they are coming at the problem with a clean slate and fresh ideas of how the problem can be solved.
However, when you learn to code, I believe you are coming at the problem already aware of some of the restrictions of your platform/language/device. As a result, the solutions you come up with are likely to be a little safer. This isn't always a bad thing - producing more sensible designs can save time, potentially be more usable and avoid disagreements between yourselves and the developer(s).
But sometimes you don't want sensible designs. You want something that's going to make the users say "wow!"
So before you jump into coding, remember to keep pushing the boundaries of your designed experiences too.
Respect the professions
Consider the Oxpeckers and the Zebras of this world. They live in symbiotic harmony because they work together.
Designers and developers should be no different.
Design is a real job. Development is a real job. Both provide crucial deliverables during each stage of the production process.
A great app can't exist without code, and it can't exist without great designs to base that code off of either.