DeepSeek V4.1 Flash Is WAY Better Than I Expected

Published
Sep 23, 2026
Duration
8:16
Click to load the YouTube player

Give DeepSeek V4.1 Flash a small interactive prototype with a clear test: walk through a castle entrance, inspect a watch mechanism, fire a trebuchet or assemble a roof. Ask for a runnable project and explicit controls. Then use those controls and record the defects before adding more detail.

That workflow makes the model’s output easier to judge. Superbash’s September test produced a recognizable Helm’s Deep scene, a detailed watch, a working trebuchet shot and a substantially formed temple roof. It also exposed clipping, uncomfortable camera movement, an awkward flying character and unfinished geometry. The useful deliverable was a set of prototypes with identifiable next steps.

The examples below preserve those results and turn them into build briefs and acceptance checks. The setup guidance is checked against current official documentation. It was not used to generate a new set of benchmark runs for this article, and the suggested briefs are not the exact original prompts.

Before you start: choose the model version and a project you can inspect

You need an account with access to DeepSeek, a coding agent that can edit and run local files, and the dependencies required by your chosen browser project. Use a separate project directory or a recoverable copy of an existing demo. Supply the agent with the repository’s instructions and ask it to identify the start and build commands before editing.

A model endpoint supplies responses; the surrounding coding tool supplies file access, terminal execution and whatever visual inspection it supports. Do not assume the model can see a running scene just because it generated the code. Ask the agent to state whether it can inspect the result, and plan to play the demo yourself.

Record the exact provider, model, date and settings. The source tested the September V4.1 Flash release. As checked on October 28, 2026, DeepSeek’s current deepseek-flash API name serves DeepSeek-V4.1-Flash-1017. Legacy Flash names also route to the newer checkpoint. A run today through that alias is therefore not a replay of the September model. See the current API guide and October release announcement.

For an existing OpenCode installation, DeepSeek documents this connection route:

  1. Start opencode in the project directory.
  2. Enter /connect, choose DeepSeek and provide your DeepSeek API key through the credential prompt.
  3. Use /models to choose the available Flash model and confirm the selected provider/model before starting the task.

The DeepSeek integration guide still illustrates a legacy V4-Flash label; the current API documentation explains its newer routing. OpenCode’s model-selection documentation confirms /models. If you need to install the coding tool, follow its current platform-specific installation instructions linked from the integration guide. Do not assume an old model label pins an old checkpoint.

This is one supported setup route, not a claim that Superbash used it for the recorded runs. Once connected, start with a read-only request to identify the project structure and available checks. Then ask for the first implementation stage.

Understand what the architecture does, without mistaking it for a small download

The source’s “two halves” explanation refers to a causal encoder-decoder architecture. The original model has 40 layers split into a 20-layer encoder and a 20-layer decoder. The encoder processes the input and prepares information for the decoder; most of a long prompt avoids a full second pass, although a recent section is replayed. Generating the answer uses both halves.

The reported figures are about active work per token: roughly eight billion parameters during input processing and 16 billion during output generation. The underlying model is much larger. DeepSeek’s original model card lists 552 billion backbone parameters. “Flash” and the active-parameter figures do not mean you can load the full model as an eight-billion-parameter desktop model.

The design also compresses the context cache. That matters to an agent that repeatedly reads files and tool results before writing the next change. It is a reason to investigate input-heavy workflows, not a measurement of the bill or memory use of your particular project. The source explains the architecture from 0:34.

The vendor comparison was mixed: DeepSWE v1.1 placed V4.1 Flash at 74.2%, Opus 5 at 74.0% and GPT-5.6 Sol at 73.0%; Terminal-Bench 3.0 put Flash behind both. These figures come from DeepSeek’s model card; the source discusses their relative ranking. They are not Superbash’s independent benchmark results. The original model card documents the evaluation settings. Use the rankings to choose a task to test, not to skip testing it.

Write one prototype brief with observable success conditions

Choose the hardest useful interaction, then keep the first environment small. For a walkable scene, that may be reaching an entrance without falling through the floor. For an assembly, it may be stepping backward and forward without losing pieces. Start with a working route through that interaction before asking for decorative variety.

A suggested brief is:

Build a small browser prototype in this project. First identify the existing framework and run commands. Implement the core scene and the named interaction. Provide visible controls and a way to reset. Preserve editable source files. Run the available checks, inspect the result if your tools allow it, and list any defects you could not verify or fix.

Follow that with a scene-specific requirement. “Make a beautiful castle” leaves too much unspecified. “Show a long defensive wall against surrounding mountains, connect the approach to the entrance with a causeway, and let the player walk that route” describes something you can inspect.

Keep a simple test log with the initial result, a reproducible failure and the next requested change. Save a working version before a substantial revision. That gives you a fair basis for deciding whether the next pass improved the prototype or merely changed its appearance.

Test a detailed environment for both recognition and traversal

Helm’s Deep worked visually because it captured three features Ron cared about: the long wall, the mountain setting and the causeway. A generic castle would not satisfy that brief even if its lighting looked attractive. Define comparable landmarks for your own scene and inspect their relationship from the approach, not only from a flattering overhead camera.

Helms Deep prototype showing mountains, a long wall and the approach to its gate.
At 2:11, the mountain setting, wall and causeway make the scene recognizable. Walk the approach as well as inspecting the silhouette: the source also encountered clipping on this route. Source frame; open the image for full size.

The recorded prototype could be explored, but the causeway exposed clipping through walls or flooring. Ron also suspected a blocked passage and then found he could get across. Preserve both observations: one suspected fault did not recur at that moment, while the earlier traversal problem still mattered. A navigable environment is not yet a finished siege game. See the walkthrough from 1:42.

For a useful first playtest, start at the intended spawn and walk the full approach. Stop at changes of slope, narrow openings and wall junctions. Repeat the route in reverse. Try the interactions the scene actually advertises, such as jumping, and note the exact place where the camera or player passes through a surface. Save a short recording for motion faults; one still rarely explains how the failure happened.

Ask the agent to distinguish visible geometry from collision geometry. Your report might say, “On the upper causeway, moving toward the gate puts the viewpoint below the walking surface; inspect the floor collision and repeat this route.” That is a repair request, not a claim that collision is definitely the only cause.

The team’s code review also reported grouping static scenery that shared a material into fewer drawing batches. Three.js documents geometry merging as a way to reduce draw overhead in its optimization guide. For your own project, ask the agent to identify the repeated static geometry and measure before and after any change. Keep objects that must move independently separately controllable. The source supplied no numerical frame-rate improvement, so do not assign one to this prototype.

Keep an animated mechanism coherent and its camera comfortable

The watch gives two separate things to evaluate: the modeled parts and the controls used to inspect them. The source showed a clean, detailed mechanism with actual 3D gear shapes. Its reported animation used one simulated clock, keeping the parts’ timing connected when playback speed changed. It did not calculate contact between every pair of gear teeth.

DeepSeek watch mechanism showing modeled gears, hands and an open dial ring.
The mechanism at 3:40 shows the detailed parts worth preserving. The source reports coordinated animation from a shared clock, while the camera interaction still needed work. Source frame; open the image for full size.

That can be a useful approach for an explainer. Ask for the parts to stay coordinated through pause, resume and speed changes, and describe any simplified behavior. Do not present a visually convincing mechanism as an engineering simulation unless the relevant physical behavior has been implemented and validated.

A suggested acceptance pass is to watch the mechanism at its normal speed, pause it, resume it and try a slower setting. Then change the viewing angle and return to the initial view. Check whether parts jump unexpectedly, keep moving while supposedly paused or lose their relative timing. These are proposed tests; the source does not certify every one as passed.

The recorded camera interaction was uncomfortable. Ron’s attempts to zoom and move around the watch became dizzying, despite the strong appearance of the mechanism. The watch section starts at 3:34. Treat camera behavior as part of the product: the viewer must be able to inspect the object without fighting the controls.

If your implementation uses Three.js OrbitControls, its official reference exposes rotation speed, zoom distance limits and damping. Damping requires update() in the animation loop. Ask the agent to inspect the existing control configuration before adjusting it, then repeat a small set of deliberate gestures. A reset view helps distinguish a poor starting camera from controls that become unstable after several inputs. This is added implementation guidance, not a claim that changing one setting would have fixed the source run.

Separate a trebuchet’s simulation clock from the display

The Stormwind trebuchet launched a projectile with its default settings and reached the castle gate. The environment and visible shot made a strong prototype, but the reported implementation is the more reusable lesson: motion advanced in 240 small steps per simulated second, separately from screen refresh. The arm and sling were coupled, and projectile flight included air resistance.

DeepSeek trebuchet scene with the machine, target gate and adjustable simulation controls.
At 4:50, the machine and settings are visible before the demonstrated default shot. Use a reset and the same settings when testing repeatability; the reported 240 updates per second are simulation steps, not display frames. Source frame; open the image for full size.

That means a simulation step of 1/240 second, about 4.17 milliseconds of simulated time. It does not mean the browser displayed 240 frames per second. A consistent physics step helps avoid changing the calculation just because one machine draws fewer frames. The actual stability and accuracy still depend on the equations, parameters and handling of elapsed time. The code discussion begins around 5:11.

Build your test around repeatability. Reset the machine and fire the same preset several times. Record the impact location or the demo’s own numerical result. Change one setting, reset and repeat. Ask the agent to explain where it advances physics and where it renders the scene. If it claims a fixed-step simulation, inspect that code path rather than inferring it from smooth animation.

For a stronger comparison, repeat the same preset under different rendering loads on the same build. If the trajectory changes substantially, investigate timing and state reset before adding more effects. The source’s successful default shot is not evidence that every slider combination is physically correct, or that the result predicts a real machine.

Keep the launch controls visible and provide a reset. A dramatic projectile trail is useful feedback, but it should not prevent you from seeing the release, flight or impact. Decide which measurements the prototype needs for its intended teaching purpose and label approximations honestly.

Inspect an assembled roof as connected surfaces

The Chinese architecture demo produced a much more complete roof than many attempts Ron remembered, while remaining a little incomplete. Its reported construction used shaped surfaces with tile ridges in the geometry. Main slopes and end sections met along shared edges, avoiding a separate scene object for every roof tile.

Temple assembly showing roof slopes and the supporting timber structure.
At 5:58, the assembled roof has a coherent overall shape. Ron still identifies unfinished detail. Inspect the joins and hidden sides instead of treating this view as proof of complete geometry. Source frame; open the image for full size.

For a browser assembly, the first task is to make the large surfaces fit. Ask the agent to identify the ridge, eaves, main slopes and end sections, and to explain how adjacent edges line up. Then inspect from multiple directions with labels hidden where possible. Labels can help identify parts, but they can also cover the gap you need to see. See the roof inspection from 5:42.

Move through the assembly stages and back again if those controls exist. Check that a roof section does not disappear at one angle, leave a seam as it moves or remain behind after a reset. A complete-looking front view is not enough to judge the unseen side or underside.

Use geometric detail where the viewer needs it. Tile ridges can communicate the surface without thousands of independent objects. If your application needs individual tile removal or close inspection of each tile, that changes the requirement and may justify a different construction. Choose the representation for the interaction you intend to support.

Ron described this as the first Flash-model roof completion in his own testing, even while acknowledging unfinished details. DeepSeek’s explanation that earlier models struggled because they managed too many individual tiles remains a model-provided diagnosis, not an established explanation of every earlier failure. The practical evidence is the shape and implementation reported for this run.

Include the weak outputs in the decision

The source deliberately skipped some poor runs and briefly showed an awkward flying-character result. Do not calculate a reliability claim from the four stronger examples alone. Keep failed starts, broken interactions and abandoned attempts in your own test log, including any retry cost.

Close crop of the flying character in the weaker broom-flight prototype.
The weaker flight run at 4:37 remains part of the evaluation. This close crop shows the character; the awkward movement discussed in the source requires playback to assess. Source frame; open the image for full size.

A useful comparison gives each model the same core brief and acceptance checks, then records the interventions it required. Note whether the agent fixed its own error, needed a precise instruction or required a handoff. If one model receives extensive help and another receives none, their final screenshots do not represent an equal-effort comparison.

The team’s operational choice was to use DeepSeek for a first version of an idea that might otherwise be expensive, then hand promising work to GPT-6 Astra. Astra remained its main model. Ron’s enthusiasm about Flash’s value was a judgment from these outputs, not a matched invoice or a demonstrated universal cheapest-model result. The references to ongoing Sol, Luna and Opus 5.5 tests, including an Anthropic account restriction, do not add completed comparisons to this experiment.

Budget for attempts and the work needed to finish

Check the provider’s current prices before a large run. On October 28, DeepSeek’s pricing page listed the following direct API rates for the current Flash endpoint, per million tokens:

UsageOff-peakPeak
Cached input$0.003$0.006
Uncached input$0.15$0.30
Output$0.60$1.20

Peak hours were listed as 01:00–04:00 and 06:00–10:00 UTC on weekdays excluding Chinese public holidays; the remaining hours were off-peak. These are current direct-provider prices, not the historical cost of the recorded prototypes or a promise about a reseller’s bill.

As a hypothetical calculation, two million uncached input tokens and 200,000 output tokens would cost $0.42 at those off-peak rates: $0.30 input plus $0.12 output. The same quantities at peak rates would be $0.84. This example excludes other billable services and assumes all input is uncached. Use actual cache-hit, cache-miss and output usage from your run when calculating its cost.

Then add the work that matters to completion: failed attempts, review time, revisions and any stronger-model handoff. A cheap first pass can still be useful, but its price alone does not tell you the cost of a usable result. Save enough of the prototype and its test log that the finishing agent can preserve the successful work.

Troubleshoot the prototype before expanding it

Use one reproducible problem per repair request and rerun the relevant interaction afterward.

SymptomInspect firstAcceptance check
Wrong model or unavailable selectionProvider credentials, model identifier and alias routingConfirm the selected endpoint and record the actual version where exposed
Scene looks right but traversal clipsWalking surface, collision representation and routeRepeat the same approach in both directions
Watch camera is uncomfortableRotation/zoom settings, target and reset viewPerform the same small gestures without losing the object
Animation changes after speed adjustmentShared simulated time and pause/reset stateResume and change speed without an unexplained jump
Trebuchet shot varies with rendering loadFixed-step updates, elapsed-time handling and initial stateRepeat the same preset and compare impacts
Roof looks complete from only one sideSurface joins, visibility and assembly stateInspect all sides and step backward through the assembly
Agent declares success without showing itFiles, run command and actual test evidenceOpen the project and repeat the claimed interaction

For a handoff, include the runnable project, the selected model and settings, the original brief, what already works and a short defect list with reproduction steps. For example: “Preserve the castle silhouette and material batching. Fix the upper causeway traversal, then rerun the route from spawn.” That gives the next agent a concrete repair while protecting the prototype’s strongest result.

Expand only after the first interaction survives that review. Keep the passing version and its test log so the next change can be checked against it.