Testing Gemini 2.5 Flash on Coding and Video Understanding

I start with a 3D demo originally made with Gemini 2.5 Pro. Rather than give Flash the original code, I download the demo video, upload it to Google AI Studio and ask it to recreate what it sees using Three.js in a single HTML file. The video uses about 10,500 tokens out of the one-million-token context shown.

Flash thinks for 22 seconds and produces code and an explanation. The result is not identical to the source, but I can rotate the shape, change its colors, zoom into its component squares and switch among a cube, pyramid, torus, plane and waveform.

I included a specific import-map instruction because my earlier Flash generations repeatedly failed to load Three.js locally. With that instruction, these examples work for me; Gemini 2.5 Pro did not have the same problem in my earlier tests. Pro is slower and more expensive, but I find it more capable.

Next I reuse my Rubik’s Cube prompt. Gemini 2.5 Pro had produced a working version on its first try in my earlier test. Flash renders a cube that can be resized and rotated, with mostly correct colors, although the image appears darker than expected.

The first Flash attempt fails when I press scramble: the console reports that a scramble completed but records zero moves. Rotating individual faces also produces awkward color changes. I suspect a few more prompts might fix it, but I leave this example at the initial attempt.

The solve button also does not visibly solve the cube and produces an error. That matters because a convincing visualization is not the same as a working simulation. I contrast this with the earlier Pro result, which I say handled the task on its first try.

For the next test I ask for an interactive Three.js bloodstream containing red and white blood cells and viruses, with controls for virus counts, replication, white-cell behavior, flow and simulation speed. I use a single HTML file to make the demo easy to run.

The generated code produces a local Three.js reference error, which I copy back to the model; it did run in Canvas. I count it as a one-try pass in Canvas, while noting that the local setup required a correction.

The simulation lets me rotate and zoom into the bloodstream, increase the number of viruses, and adjust replication and white-cell settings. Two requested virus types, stealthy and fast-replicating, are labeled as not implemented, so the result does not satisfy every part of the prompt.

I find a duck-sorting game on X and upload its video to Flash, asking for a single-file Python version with procedural animation. The objective is to move a white sorter and group ducks by color. The interface reports one token for the video, a figure I question rather than accept as the actual cost.

The model identifies elements such as the title and game screens, cursor-following movement, collisions and boundaries. I go back and forth several times to adjust settings before reaching a version that looks much like the video, although the sprites are less polished.

In the resulting game I can herd colored ducks and see them bounce back from the edge. The win condition had worked in an earlier iteration but is broken in the version shown. Despite that flaw, I find the video-based recreation impressive.

Producer Alex makes a tower-defense game using a detailed HTML5 Canvas prompt. He starts with a basic idea and uses an LLM to help write the specification, which calls for waves of color-coded balloons and five tower types with different attack behaviors.

The demonstration places ice towers to slow enemies and dart towers to attack them. The first wave completes, the player earns money and the next wave has stronger enemies. The basic mechanics work, though the presentation could use more visuals and complexity.

I revisit a complex Snake prompt requesting Pygame, visual effects, different food types and a human-versus-AI contest. My earlier Pro version had striking visuals; Flash also produces a playable game with two snakes and effects, but I find it less visually impressive.

The Flash Snake program is 677 lines of code. I observe that both Gemini 2.5 models have produced unusually long outputs in my experience; this is my anecdotal comparison with other models, not a controlled test or a universal line limit. Flash is faster and cheaper in my assessment, so the right choice depends on the task.

Alex also asks Flash for two AI players competing at Tetris in Python and Pygame. The specification includes 10-by-20 grids, no hold or T-spins, and garbage lines sent to the other player when lines are cleared. The rule-based players aim to minimize holes and stack height while clearing lines.

Alex makes many follow-up changes before the Flash version works as shown. Both AI players place pieces and exchange garbage lines until one reaches the top. This final result is the product of iteration, not a single-shot generation.

I then run the same Tetris prompt on Pro once. The result looks and behaves very similarly, including a display cutoff that also appeared in the Flash version; it runs more slowly in my demonstration. The comparison uses different numbers of iterations and is not a controlled benchmark.

Another creator shares a Galton board example: balls fall through a field of pegs and collect in bins, tending toward a bell-shaped distribution. I take the creator’s text prompt and also download the reference video to show Flash what the result should look like.

The first result is missing the bottom cups. I upload the video and ask the model to add them, then iterate on the width and fix another problem in which balls disappear after landing. I am struck by how quickly Flash regenerates the code after feedback.

The finished simulation includes controls for the number and size of balls, drop interval, gravity, peg size and spacing, number of bins, bounce and friction. Some combinations cause balls to become stuck, and increasing the bin count runs out of space, so not every control behaves as intended.

Alex’s next example is a drawing-app simulation. Although the discussion initially calls it an iPhone app, the prompt asks for a simulation and the output is a Python program. It offers pen settings, colors, an eraser, rectangles, fill and a way to save a PNG.

For the final test I upload a 16-minute Popeye cartoon and ask detailed questions about visual moments. The upload uses approximately 283,000 tokens in the interface. I extrapolate that the million-token context could hold close to an hour, although the actual capacity depends on how video is processed.

I ask how many lions Popeye fights around the eight-minute mark. Flash answers two, and I check the video. It also identifies the text on a sign with two snakes near the beginning: “Isle of Sinbad — Beware,” along with the skull and crossbones.

A harder question asks what is written on a barrel around ten minutes in. I check the footage, where the text is partly obscured for much of the scene, and find the answer includes “XXX” and “buckshot.” These examples show success on a few selected questions, not comprehensive video comprehension.

My conclusion is that Flash comes close to Pro on many of these examples while responding faster and costing less, though it is not as capable in every case. Many tasks do not need the most expensive frontier model, so I recommend choosing according to the actual job.