Claude Haiku 5.5: Can the Cheapest Claude Build Celeste's Jump?

Claude Haiku 5.5 just came out, and it's the cheapest Claude there is. Can it build a platformer jump that feels like Celeste's? One room in Godot, six things to get right: variable jump height, coyote time, jump buffering, a hang at the top, corner correction and a fast fall, each with a pass mark set before the first run and no stricter than Celeste.

Source: https://flockbay.com/blog/claude-haiku-5-5-builds-a-celeste-style-jump-in-godot/ · Updated 2026-10-09

First, how shipped games jump: Super Mario Bros., Bubsy 3D, Castlevania and Celeste. Then Haiku builds it in Claude Code over Flockbay's MCP server, in passes. After each, we measure all six and send back the numbers against the bar, never the fix. A last pass dresses it.

The exact first prompt, given with a reference picture:

Build one mechanic for a 2D side-view platformer in Godot: the jump. It has to feel as tight and forgiving as Celeste's. The player is a CharacterBody2D in the group player, drawn as a rectangle about 1 tile wide and 1.5 tiles tall. This pass is a grey-box in the clean, flat look of the reference picture: build everything from primitives, and don't download or generate any art or sound. The picture shows the look; where its layout differs from these words, build the words. The game is one room that fills a 1920 by 1080 screen, and the camera never moves. Lay the room out on a grid of 48-pixel tiles, 40 across and 22.5 down, counting columns from 0 at the left. The floor is the bottom 2.5 tiles of the screen, a solid wall closes each side, and there is no ceiling. From left to right: open floor from the left wall to column 10, with the player starting at column 3; at column 10 a step one tile high, after which the floor stays at that height to column 17, making a ledge; from column 17 to column 22 a gap 5 tiles wide that drops out of the bottom of the screen, wide enough that only a jump at full running speed clears it, and falling into it puts the player back at the start; then the floor again at its first height, all the way to the right wall. On that floor, at columns 25 and 26, stands a block 3 tiles tall. From column 32 to the right wall, a shelf one tile thick sticks out of the right wall with its underside 3 tiles above the floor, so its left end is a corner hanging over open floor. The player runs left and right at about 11 tiles a second: the left and right arrows or A and D run, Space jumps, and R puts the player back at the start. The jump is the point. A quick tap of jump is a short hop that gets up the step but not over the tall block, and holding it goes much higher, over the block. Running off the ledge and pressing jump a moment too late still jumps, but there is no jumping in mid-air after that. Pressing jump a moment before landing jumps the instant you land. The jump hangs for a moment at its peak. A jump whose head clips the shelf's corner by a few pixels slides past the corner and keeps going up instead of stopping. And you fall faster than you rise. Make every key above an input action so it can be pressed by name: move_left, move_right, jump and restart. Nothing else yet: no enemies, no pickups, no dash, no wall jump, no menus and no sound. The look comes in a later pass, so keep the scenes and scripts easy to build on. Run and test the game only through Flockbay's tools: flockbay_play, flockbay_run_headless, flockbay_script_errors, flockbay_game_input, flockbay_game_get, flockbay_game_set, flockbay_game_screenshot, flockbay_game_step, flockbay_game_time, flockbay_last_run and flockbay_stop. Don't start Godot from your own shell, and if one of those tools can't do something you need, say exactly what was missing in your handover. Playtest it yourself and hand it over when you think it's done.

The jump against the scorecard: six rows, each a drive that can be run again.

How it plays beside the shipped games of the opening.

How it is built: where the jump's state lives, what each gravity is switched by, what the coyote and buffer timers count.

What it took: the passes, the minutes, its own Plays, and the estimated API bill beside the same tokens on Opus.

The look, after the look pass: the same room dressed, beside the reference.

Claude Haiku 5.5 ran in Claude Code for 12 minutes on the prompt above, with Flockbay’s tools connected over MCP: 95 calls to Flockbay’s tools and 10 to Claude Code’s own. Every call, from the run’s transcript:

Every check the run made passed. Its last, flockbay_script_errors, returned:

No errors in 2 scripts.
Scripts under res://addons were not checked; pass include_addons to check them.

Lines 1 to 40 of 95, from the game folder at the end of the build.

extends CharacterBody2D

const RUN_SPEED := 528.0
const RUN_ACCEL := 6000.0

const JUMP_HEIGHT := 170.0
const JUMP_TIME_TO_APEX := 0.24
const FALL_GRAVITY_MULT := 2.0
const JUMP_CUT := 0.4
const APEX_HANG_SPEED := 150.0
const APEX_HANG_GRAVITY_MULT := 0.3
const MAX_FALL_SPEED := 2400.0
const COYOTE_TIME := 0.1
const JUMP_BUFFER_TIME := 0.12
const CORNER_NUDGE := 16.0
const FALL_RESPAWN_Y := 1152.0

@export var spawn_position := Vector2(168, 924)

var _gravity_up := 0.0
var _gravity_down := 0.0
var _jump_speed := 0.0
var _coyote_timer := 0.0
var _buffer_timer := 0.0
var _can_cut_jump := false

func _ready() -> void:
    add_to_group("player")
    _gravity_up = 2.0 * JUMP_HEIGHT / (JUMP_TIME_TO_APEX * JUMP_TIME_TO_APEX)
    _gravity_down = _gravity_up * FALL_GRAVITY_MULT
    _jump_speed = _gravity_up * JUMP_TIME_TO_APEX
    respawn()

func respawn() -> void:
    global_position = spawn_position
    velocity = Vector2.ZERO
    _coyote_timer = 0.0
    _buffer_timer = 0.0

Download Flockbay free: Built in Flockbay, a free AI game maker built on Godot. https://flockbay.com/free-ai-game-maker/

Related: Why Celeste feels so good to play, How to make games in Claude Code, Make a platformer with AI

I make Flockbay, a free AI game maker built on Godot. The original is on flockbay.com.