DeepSeek-V4-Pro Hands-On: 12-Style Blog & 3D Racing Game Generated in One Shot

DeepSeek-V4-Pro Stable Release: Parameters & Pricing Breakdown

DeepSeek recently officially released the stable version of V4 Pro, with the official model identifier DeepSeek-V4-Pro-0813. According to hands-on testing by a Bilibili content creator, this version maintains backward compatibility in its API calling methods, meaning developers can upgrade seamlessly without modifying existing code—a welcome signal for teams already running DeepSeek in production environments.

Based on officially published specifications, V4 Pro supports a maximum output context of 384K tokens, is compatible with both thinking and non-thinking modes, and has thinking mode enabled by default. A 384K-token output context window is among the most cutting-edge specs in current large language models—for reference, GPT-4 Turbo's context window is 128K, and Claude 3.5 Sonnet's is 200K. A larger output window means the model can generate longer complete content in a single call—for instance, outputting an entire frontend project's code at once rather than generating it in segments that need stitching together. The default-enabled thinking mode (Chain-of-Thought reasoning) means the model prioritizes expanding its internal reasoning chain when handling complex tasks, analyzing problems step by step before outputting final results. This mechanism shows significant improvement in mathematical proofs, code debugging, and complex logical analysis, but at the cost of consuming more tokens and time—essentially trading some speed for higher output quality.

Regarding pricing, V4 Pro costs approximately three times that of the previous V4 Flash. Specifically:

• Input (cache hit): ¥0.025 per million tokens
• Input (cache miss): ¥3 per million tokens
• Output: ¥6 per million tokens

This pricing strategy clearly targets scenarios with higher quality requirements and relative cost insensitivity. The caching mechanism deserves special attention. KV Cache (Key-Value Cache) during LLM inference is a core optimization technique—when users make multiple API calls with identical input prefixes (such as the same system prompts or context), the server can reuse previously computed Key and Value tensors from the attention matrix, avoiding redundant computation. The cache-hit price of just ¥0.025 per million tokens represents a 120x reduction compared to the ¥3 cache-miss price. This extreme price differential is designed to incentivize developers to structure prompts with fixed prefixes, placing variable content at the end of inputs to maximize cache hit rates. In high-frequency calling scenarios like RAG (Retrieval-Augmented Generation) and multi-turn conversations, leveraging this mechanism effectively can dramatically reduce operational costs.

The MoE (Mixture of Experts) architecture used by the DeepSeek series is the underlying technical foundation for its cost control. Although MoE models have enormous total parameter counts (e.g., DeepSeek-V3 at 671B parameters), each inference only activates a small subset of expert networks (approximately 37B active parameters), so actual computational costs are far lower than dense models of equivalent scale. V4 Pro being priced at three times V4 Flash likely means the Pro version activates more experts, uses deeper reasoning chains, or has quality-prioritized adjustments to its MoE routing strategy, while the Flash version achieves cost compression through more aggressive expert sparsification—suitable for latency- and price-sensitive scenarios.

Benchmark Expectations: Steady Improvement but Still Has a Ceiling

Since the model was just released, some publicly available benchmark scores are still estimates. From a logical standpoint, V4 Pro's benchmarks should be higher than the previous V4 Flash-0731 version, which aligns with reasonable expectations for version iterations. However, the reviewer also rationally pointed out that, at least so far, it has not yet surpassed top-tier competitors. This reminds us that evaluating a model shouldn't rely solely on benchmarks—actual task performance is what truly matters.

Test Case 1: 12-Style Personal Blog Generated in One Shot

The first test case focused on frontend generation capabilities. The prompt asked the model to design a modern personal blog website offering six visual styles (minimalist black & white, tech futuristic, warm retro, clean dark, etc.), and required complete pages including homepage, article list, article detail, about us, and contact.

The entire task took approximately 25 minutes to execute. The generated result was remarkably complete—the homepage logically organized author bio, featured articles, content categories, recent updates, and contact entry points, with article categories, archives, and detail pages all properly written. More noteworthy is the style-switching panel in the bottom-right corner: six base styles paired with light/dark modes effectively create 12 switchable visual schemes.

Attention to Detail in Style Switching

When switching styles, an easily overlooked detail was handled well: after switching styles, the page stays at the current scroll position rather than refreshing back to the top. Additionally, text typography styles adjust dynamically with overall theme changes, and the floating switch card in the bottom-right corner is also quite polished.

It's important to emphasize that DeepSeek is a non-multimodal model—it cannot actually "see" how the page renders. All visual design relies entirely on linguistic understanding of CSS and layout logic. Multimodal models (such as GPT-4o, Claude 3.5 Sonnet with Vision) can process both text and image inputs simultaneously, able to "see" rendered results and adjust designs accordingly. A text-only model doing UI design relies entirely on understanding HTML/CSS/JavaScript semantics and statistical learning from vast amounts of frontend code and design patterns in its training data. It knows what color values, fonts, and spacing correspond to a "minimalist black & white style," but cannot iteratively refine through visual feedback like a human designer. Given these constraints, the fact that DeepSeek can generate 12 aesthetically pleasing schemes with clearly distinct styles demonstrates remarkably solid frontend design pattern knowledge.

Test Case 2: 3D Racing Game Generated in 40 Minutes

The second case significantly raised the difficulty level, leveraging Agent Coding capabilities (launching a coding agent workflow). Agent Coding represents a major paradigm shift in AI programming during 2024-2025—unlike traditional code completion, it gives the model autonomous planning, execution, verification, and repair capabilities in a complete workflow. Specifically, the model breaks a large task into multiple sub-steps, generates code sequentially, runs tests in a sandbox environment, and if errors are found, automatically analyzes logs and applies fixes, forming a closed-loop iteration. Representative products include Cursor's Agent mode, Claude Code, and autonomous programming agents like Devin.

The prompt requested development of a playable 3D racing game that includes car controls, a track, opponent vehicles, real-time rankings, collision effects, and restart functionality, with visuals conveying a sense of speed, delivered as a complete runnable project.

This task took approximately 40 minutes to execute. Notably, the model not only generated code but also conducted its own testing and bug fixes, and included a complete ReadMe document explaining gameplay and controls (accelerate, brake, left/right steering, spacebar for brake drifting, restart, etc.). This exemplifies Agent Coding's closed-loop capability—it's not just a code generator but a self-verifying development agent.

Actual Game Performance: Playable but Visually Limited

Upon entering the game, first impressions are positive: the car starts with sound effects, braking, cornering, and drifting operations all respond properly, speed is displayed in real-time at the top (tested up to 223), and collision detection works—crashing produces clear feedback. The game also simulates wind particle effects to enhance the sense of speed and implements real-time ranking logic—the process of overtaking from second place to first is fully functional, and the track even includes complex structures like roundabouts.

However, limitations are also evident: car models are fairly rough (front wheels even appear flat as if deflated), and distant mountains and clouds lack realism. These visual shortcomings precisely confirm the non-multimodal nature mentioned earlier—the model cannot refine visual details through visual feedback and can only construct 3D scenes based on code logic. The visual aesthetics of 3D objects depend more heavily on post-render visual judgment, and text-only models have an inherent blind spot here. Being able to produce a playable game with physics feedback and complete delivery in a single generation is already quite impressive Agent Coding performance.

Summary: Is DeepSeek-V4-Pro Worth Using?

Across both test cases, DeepSeek-V4-Pro demonstrates the following characteristics:

• Stable long-task execution: Both the 25-minute and 40-minute continuous tasks delivered complete results with self-testing and self-repair capabilities, well-suited for Agent Coding scenarios.
• Solid frontend aesthetics: As a non-multimodal model, it generates 12 styles with well-handled details, demonstrating robust frontend design knowledge.
• 3D generation is usable but not refined: Physics logic and interactions are complete, but visual precision is limited by model attributes.

For developers pursuing "generate once, deliver ready" workflows, V4 Pro's performance is commendable. However, if extremely high visual fidelity is required, you'll need to pair it with multimodal tools or manual post-processing. Whether the three-times-Flash pricing is worth it ultimately depends on your specific use case and output quality requirements.