Puzzle platformers fail in the seam between the two halves

Platformers want forgiveness. Coyote time, generous hitboxes, input buffering, a little corner correction so a clipped ledge does not stop you dead. All of it exists so that failure feels like your mistake rather than the game being unfair.

Puzzles want precision. The solution should be exactly one thing, and near-misses should not accidentally work. If the forgiving jump lets the player skip the box they were meant to push, the puzzle evaporates.

Every puzzle platformer lives on that seam. Too loose and the puzzles fall apart. Too tight and the execution becomes the difficulty, which is not the difficulty you designed. Finding the balance means changing both sides repeatedly and playing after each change.

More on this: Make a platformer with AI: getting the jump right is the whole job

You describe the movement: this jump height, this air control, forgiveness here but not there. Flockbay writes the GDScript inside your Godot project. You describe the puzzle rule: this block only slides on ice, this switch stays held while something heavy is on it, this door closes behind you.

Then you play it and find the exploit, because there is always an exploit. The player can jump over the thing they were meant to route around. You say so, and the rule tightens.

That is the entire development process for this genre, and its speed determines whether the game is good. When each change is a sentence rather than an afternoon, you get to run it a hundred times.

More on this: AI logic puzzle maker: the rule is small, the consequences are not

A puzzle platformer room is a small, deliberate space where every ledge is either part of the solution or a deliberate red herring. There is no such thing as decorative geometry in a room like that, because the player will assume everything is meaningful.

Flockbay builds those rooms from the brief you approved and plays them first, so a ledge it made unreachable gets caught before you arrive. Then you stand in them, check what is visible from the entrance and in what order the player will notice things, and play the room pretending you do not know the answer, which is the hardest and most valuable thing you will do.

Whether the rooms are 2D or 3D is settled in the brief, before anything is built. In 2D a room is tile ground: Flockbay marks which cells are ground, and the tiles, the edges and the collision all follow from that, so every ledge is one the player can land on and climb. Everything else is a sprite from your project at an exact position, rotation and scale, so the box the puzzle turns on stands on the floor rather than hovering above it.

In a room this exact, one tile matters. Paint, Place and Player controller are buttons around the Godot editor's 2D view, so when a ledge should sit one cell lower you can drag it there yourself, play it again, and Godot's undo takes it back if the skip comes back with it.

Pick 3D and the room gets that side's own tools instead (real terrain, water and weather), which suits a puzzle platformer built into a landscape. Neither is the lean. The flat world has a shorter list of tools, because water and weather have nothing to describe without depth. None of what this genre actually lives on — the jump, the rule, the room — is on the missing part of that list.

More on this: AI side scroller game maker: one axis, a lot of precision

A desktop app for Windows and Linux with Godot bundled inside. The game runs locally when you press play, at your machine's framerate, which matters when execution timing is part of the puzzle.

Building needs an internet connection. Playing what you built does not. Free to download, and the world tools cost nothing to use. Flockbay is free, AI included: free hosted AI every day, or your Claude or ChatGPT plan, your own agent, or an API key.

More on this: Make a puzzle game with AI: the rule is small, the levels are the work

The best rooms in this genre come in pairs. The first shows you what the rule does in a situation you cannot fail. The second asks you to use it somewhere that matters. Skip the first and your clever room reads as unfair, because the player is solving and learning at the same time.

That sequencing is the design job, and it is the reason the level order matters as much as the level content. A game of individually good rooms in the wrong order plays worse than a game of simpler rooms in the right one.

It also means being willing to cut. The room you are proudest of is often the one that arrives too early. Moving it later, or removing it, is usually right and always painful.

In a genre where you will fail a room fifty times, the distance between failure and the next attempt is a bigger factor in enjoyment than the difficulty itself. A one second restart makes a hard room a rhythm. A ten second walk back makes the same room a chore.

The rule of thumb worth stealing: restart at the start of the puzzle, not the start of the area, and make it instant. If the player has to watch a door open again, you have added a punishment that teaches nothing.

It is code, so it changes when you say the retry loop feels slow. Test it by deliberately failing twenty times in a row and noticing when you get annoyed.