For aspiring game designers, writing code seems both an obstacle and a necessary step.

Programming can generate a huge mess in people’s minds. If you already know how to code (even a little), you’ll probably think of ditching this post since you believe you have all the necessary knowledge. On the other hand, if you have no clue about coding, you might be scared because it seems like a wall too high to cross. Whatever category you’re in, you’re wrong.

In this post, I’ll reveal the one thing most beginner game designers get wrong about programming that prevents them from taking the leap and that you can leverage instead (even if you’ve never written a single line of code).

The Terrible And Widespread Mistake Of Confusing Coding With Programming

First, you need to understand a foundational difference.

It's crucial for the rest of the post and the first brick to change how you approach game design. So pay attention.

Despite many people using the 2 terms interchangeably, "coding" and "programming" are not the same thing. Whoever has even slightly touched Computer Science knows that writing code just means leveraging a sort of "special language" to do stuff. That's it. Whether it's C#, C++, Python, or what have you, you're writing an executable language.

This means that anyone can write code.

If you can't write a single line of code at the moment, this may seem wrong, but trust me. It's like learning a new software.

At the start, it could feel counterintuitive and complex, but you can become pretty decent with a couple of months of work. So, people who can write code indeed have an edge in some cases, but they're not geniuses. They just put the necessary time and effort into doing so. Moreover, nowadays, learning basic coding is 100% free and accessible to everyone through the web.

That's exactly like learning how to use Excel, for instance. So you too can be a "Coder" without a huge effort even if you don't feel cut out for it.

Being a programmer instead is whole another thing.

Yes, a programmer also knows how to code because he eventually needs to implement something executable. However, writing code is not the key factor of its competence. Becoming a programmer means your brain works on Algorithmic Logic (or Programming Logic).

Put simply, an algorithm is a series of instructions that a computer follows to solve a specific problem.

Mastering this knowledge has to do with problem-solving skills. It means that you can clearly understand what problem you're facing and build a solution to it.

Writing that series of instructions of the solution in a computer is the "writing code" part of programming. Potentially you could find solutions to problems and never write a single line of code. This means that Programming Logic is independent of code language.

In fact, when you plan a solution as a series of instructions, they are not written in code. They're just logical passages that you, or even someone else, then need to translate into code in a specified language.

Establishing this difference is crucial for game design.

If you don't correctly separate them, you waste, as we'll see in a moment, a huge amount of time focusing on the wrong aspect. In the game design world, this difference is not common knowledge. The reason is that the average game designer knows the "Game Programmer" role and tends to group both skills under it, and he doesn't see the difference. Yet, saying that they're the same thing is like saying that writing musical notes and composing are the same thing.

I'm sure you understand why it doesn't make sense. The lack of awareness of this difference leads to a lot of misunderstandings.

The major one is the question: "Does a game designer need to know how to code?".

And that's precisely what I'll tell you in the following sections.

Don’t Waste Time And Energy By Focusing On Code (Especially “Good Code”)

Here is something, unfortunately, not everyone understands: a game is software, but not only software.

When you design a game, the hardest part is rarely the implementation. Structuring the game so that it can generate the target experience for the player is the real struggle.

So, let me tell you something important about this. The design of the game is not the code. You don't need to know a coding language to craft the gameplay, lay out the levels, define the game balance, and so on. Coding involves making your design decisions real and concrete.

But you must have made those decisions in the first place. And you don't do them thinking about code.

So, coding is not the game designer's primary skill.

That's why using Unity or Unreal never translates to learning game design. This is true, especially at the beginning, when aspiring game designers tend to follow endless tutorials about game engines. If you avoid falling into a "Tutorial Hell", that's not inherently bad since you'll use those skills in your work. However, don't believe you're on the path to becoming a game designer because you're off the rails, to say the least.

That's easy to understand when no company cares about your portfolio because it's full of projects showing only software skills. Which I'm sure you know shows skills that are easily replaceable and keep changing with software updates.

You might ask: "What about prototyping?"

And you're right; most of the time, effective prototyping needs code. Because you need to build a rough version of your idea on a game engine so that you can test your design decisions.

But, as you can see, the focus is still not the code itself. And here's where the "utilitarian approach" to coding comes in handy. Just look for specifically what you need when you need it. Remember, you don't care about good and clean code architecture; those are programmer's stuff.

You just need something quick and dirty to test your designs. And YouTube has tutorials for specific features on all popular game engines.

So, is coding a requirement for learning game design?

The answer is 100% no. If you have absolutely no clue about coding, you'll need to get your hands dirty a bit at the start to build some prototypes.

But this is totally independent of learning game design. Just make sure not to focus too much on code that you leave aside what you really need to become a game designer. Eventually, when game design becomes second nature, you can spend more time learning how to code professionally. Some game designers do it, and I suggest you do it, too, to improve your skills even more.

Yet, to learn game design, you don't need it. Focusing on it now will only make you waste time.

This also explains why a Bachelor's Degree in Computer Science is not a good choice for becoming a game designer.

It's not a bad or useless degree; I have it myself, and it opened my mind to analytical reasoning. But precisely because I know what you do in a Computer Science course, I can tell you it's useless for game design.

You won't learn anything about game design first because there is no class about it. Then, because the skillset you acquire as a computer scientist won't teach you how to design games. So, after the degree, you'll need to put more time and effort into studying game design. You've taken the long road and could have skipped CS entirely.

People who suggest doing it either don't know what they're talking about or add some magical properties to the degree. The idea is "better to have it than not," but the mistake lies in not considering the time lost.

Remember, you're not a programmer.

The code is not the "language" you speak because it's not the language of game design. A game designer is an engineer of ideas. Code is just a tool you can use to build prototypes, nothing more.

Moreover, with AI-based code assistants, the need for a game designer to know the ins and outs of coding is becoming less and less of a priority. So don't focus entirely on it, especially if it steals your time from learning actual game design.

Let's now see what you really need to become a game designer instead.

A True (Analytical) Game Designer Is Always A Programming Logic Master

As I told you a moment ago, you're not a programmer, yet you must steal something from them.

I'm talking about that Algorithmic Logic I mentioned at the start. That's the secret ingredient of a true Analytical Game Designer who can manage any problem he faces. However, you don't need their methodologies and tools.

You must aim for the mindset and thinking skills. But let me tell you why because that's something no one talks about (not even in major game design programs).

Any game (physical and board games included) can be considered a computational system.

Let's briefly unpack this because it's easier than you think. A game is a system, meaning that it's made of elements interacting with each other according to strict rules.

Precisely becasue of this nature, you can always see a game as running on a computer (even if it's not made for it in the first place). Meaning you have a set of elements performing a series of actions and producing some effects while interacting with each other. This is true for every game, from Tag to Call of Duty.

To simplify even more, any game can be reduced to a long series of "if this happens, then this happens" instructions (which programmers know very well). And this is exactly where Programming Logic comes into play.

If your brain reasons with the analytical mindset of programmers, you understand the real core of games.

And that's a huge advantage because most "Guesswork Game Designers" out there don't have it. They just jump in with trial-and-error and randomly discover what they're doing.

You can literally see things invisible to them. You'll realize that games are not so different from each other, especially on the gameplay side. Also, you have an edge on programmers, too! You'll understand what they're talking about, and they won't trick you with basic stuff. But I see some of you raising your finger with an objection at this point.

"Then I need a degree in Computer Science to learn Programming Logic!"

And the answer is, again, no. Programming Logic is an emergent mindset in a CS program.

There's nothing specific to make you develop that way of thinking. You'll do it yourself by taking courses and studying, yet it's not guaranteed. In fact, I know some computer scientists who barely have that mindset.

They didn't cultivate it, and the purpose of the university is not to make you develop it. You'll still waste a lot of time and money and learn a lot of cool things, except game design.

In the end, you must understand that a game is not some code with a layer of design intuition and magic on it.

Becoming a master in problem-solving as an Analytical Game Designer means leaving this old way of thinking behind. If you don't do it, becoming a shallow guesswork game designer is the least of what can happen to you.

It often gets even worse. You trick yourself into believing that you already know everything and need to practice coding while keeping up with Unity/Unreal's latest features. This nightmare spiral brings you further and further away from learning game design. The real truth is that you can lack a professional analytical thinking process.

It's reasonable to think that learning to write code is the only way to go, especially at the beginning.

It seems obvious since, without code, there is no game. So, learning a coding language seems a direct path to making your game ideas come to life.

I come from a computer science background and know this mindset very well. Yet, it's a trap, and precisely that background made me realize that the game's design always comes first. Yes, of course, you'll eventually need to implement things in some way or another! But if you don't define the game's structure first, you have nothing to implement.

How are you supposed to design a game with only coding knowledge?

The answer is that you don't. You only become increasingly frustrated because you don't know how to really solve design problems and make good decisions. Also, you'll be disappointed by yourself when, despite being technically proficient, you fail to show your design skills in a portfolio. You don't emerge because you don't have what it takes when it matters.

During design interviews, they won't make you recite Unity tutorials or ask for your favorite coding architecture. They'll ask you to reason around game design problems to test your analytical skills.

And that's exactly where you need to show them you are a true Analytical Game Designer.

Someone who doesn't just jump in, execute, and randomly try out stuff until something comes out "good". You know how to manage problems effectively by analyzing the situation and deeply understanding the issue at hand. Then, you highlight a bunch of cause-and-effect relationships, showing that you know what happens in a game system as a consequence of a change. And in the end, you can evaluate the best solution according to the Game Direction and not just by following your gut and tastes.

That's how an Analytical Game Designer, a true engineer of ideas, thinks and works.

And that's exactly what you need to focus your learning efforts on.