The most important rule while prototyping is to be efficient. I love Pareto's principle which says around 80% of the consequences result from 20% of causes or efforts. In game development terms, it means that 20% of your development effort will result in 80% of the playable outcome of your game. Think about it, when developing a feature, you spend a certain amount of time getting the feature up and running, but most of the time, you catch the edge cases and/or polish the feature.

Our takeaway from this is to find the 20% of the work that will give us the maximum output. It's not just about working fast, it's also about working smart.

Third-party assets

Whenever we start the development, the first thing we should ask ourselves is if there are any assets or tools out there that we can use to speed things up. There is absolutely no need to reinvent the wheel at least for a prototype. Some developers don't like the idea of using third-party assets. The main reasons include,

It's hard to get exactly what you need

It's too heavy with a lot of stuff I don't need

I agree with the statements. But for a prototype, I say don't even worry about it. Of course, we can't use third-party assets for every little thing. But if it saves time, then we can and definitely should.

There are a lot of amazing assets in the asset store that you can use without a doubt. For example: if you are developing a game like this, you will need a spline system

And luckily for us, there are great assets for that, like Curvy Splines. Yes, it's a paid asset, but quality most of the time costs. And it will save you money in the long run. I will do a post with the most useful asset store assets to use in hypercasual prototyping.

Git

Use git! Seriously!

I don't need it. I work solo

You need it still! Git is not just about collaboration with others. It will help you in a lot of different ways. During prototyping, there is a lot of experimentation going on. It can easily happen that at a certain point you want to go back 2 days of work and resume again from there in a different direction. Git can help you go back at any point in time and resume from there. Branches in git can help you to explore different directions from a certain point to try out different gameplays

You can back up your repository free on a server so that in any case, your work is not lost.

SourceTree is a great visual git tool to make life easier and simpler

Reusables

Whenever you come across a certain feature or behavior which you are confident that you will need in the future, write it in a way that has the least dependencies. Use an adapter if you need to. I'll explain,

Consider you have a script (HealthVisual.cs) that takes the health value of the player and shows it on screen as Text. You can get a reference to PlayerHealth.cs and then get the health value from there and update it on UI. But that way, your health visual is dependent on your PlayerHealth.cs. Instead, you can keep the HealthVisual.cs script in a way that it doesn't care about the PlayerHealth.cs. It can have public functions that PlayerHealth.cs can use. The dependency gets reversed that way and you can reuse the HealthVisual.cs on other projects as well. Of course, this is a pretty simple use case. But it can be used widely for many scripts.

A great use case for such is when you can simulate the whole UI flow of a prototype using simple events or commands. At this point, you can understand that it's not just scripts that can be reusable. It can be a whole package itself.

To see more on this, check out my blog post How to think smart and code fast in Hypercasual