How We Can Communicate Better So, the first thing is that we need to establish some *ground rules*. When developers get a design, they know nothing about the product, usually, or almost nothing. And you designers know everything – you are the authority. We just lay the code bricks here and there.
So, *your job is to share your knowledge, share the context with us*, and *our job is to listen, to absorb it*. And this is a moment where there are the most problems. And I think that the reason is that we often *share some misconceptions* about each other's work, and designers often think that their job is to create a design, hand it off, and their job is done.
They also tend to believe that developers are lazy and don't do a good enough job with the designs. And, actually, that's often true, unfortunately. Even in my company – my company started as a design-only agency, and my partner is a designer, but he's seen over and over again how developers execute the design
and that the design was a totally different thing than the final product. And this is a realistic example, to be honest, so the colors are more or less fine but it doesn't look how it should at all. So, it really happens. And it happens a lot. And also, developers have many problems with designers, especially with some changes in the designs
that we are not aware of and they are made. And also, many times designers think that something is just a minor change. You have to do it, and you have to do it fast – and, for us, it's a huge thing and not possible to change in a week or even a month sometimes. So, these accusations are sometimes true but it shouldn't really matter
because we both have our flaws and we have to recognize those flaws, and focusing on that creates a really toxic and unfriendly work environment. So, I think we don't have to avoid making mistakes and talking about them, but *embrace* them. So, I think there are two important mindset shifts that can help us.
One is to *change the way we think about handoff*. So, handoff – I don't even like the word 'handoff' because it sounds like a one-time thing, and it really isn't, especially now. It's more of a process. And I really like the term that Brad Frost coined about handoff: He calls it a 'hot potato' process. And the difference between – I called it 'waterfall' here – but the old way when the designer works,
hands off the design, and then the developer works, and the hot potato process is that 'hot potato' process. In the 'hot potato' process, we work at the same time. So, usually the designers start work, they create some screens, they give it to developers, and we start building them, and we start exchanging information, communicating, improving, working in iterations. So, most digital products nowadays are created like that.
So, that's the first mindset shift. We should stop thinking about handoff as a one-time thing and *start to think about it as a process*. And the second mindset shift is *giving others the benefit of the doubt*. And I already mentioned that we will make mistakes that happen; we can fix them, we can improve them, and in my experience not thinking about designers as someone who's just an evil overlord
who changes designs when they want, but like another human being who has their problems, too, and their job is very hard. It helps a lot in cooperation.