500 Million Tokens Per Day: Real-World AI Programming Experience with DeepSeek Powering a UE5 Project

Overview

DeepSeek V4 Pro recently announced a permanent 75% discount, which is undoubtedly great news for heavy API users. A UE5 (Unreal Engine 5) developer shared his hands-on experience — consuming approximately 500 million tokens per day, with cumulative spending exceeding 1,000 RMB, deeply integrating AI programming into the entire workflow of his Unreal Engine project. This article analyzes his architecture design, cost control strategies, and actual workflow.

On the Complexity of Unreal Engine 5: UE5 is a next-generation game engine developed by Epic Games, renowned for technologies like Nanite virtualized geometry and Lumen global illumination. Its codebase is enormous — the engine core alone contains millions of lines of C++ code, and game projects must also handle Blueprint scripting, material systems, animation state machines, network replication, physics simulation, and other highly coupled subsystems. This complexity makes UE5 projects an extreme stress test for AI-assisted programming — AI needs to understand not just C++ syntax, but also UE5-specific macro systems (such as UCLASS, UPROPERTY), garbage collection mechanisms, and dependency relationships between subsystems. This makes it an ideal scenario for testing the upper limits of AI programming capabilities.

Staggering Token Consumption and Cost Control

This developer has been using the API at scale since DeepSeek's launch in late April, consuming hundreds of millions of tokens daily. He's topped up about 1,000 RMB and spent seven to eight hundred. While the numbers look staggering, the actual daily cost stays between 20-60 RMB (~$3-8 USD), thanks to two key strategies:

Tiered Model Usage: Complex programming tasks use the Pro version (stronger reasoning capabilities), while simpler tasks like code review use the Flash version. The developer explicitly states that the capability gap between Pro and Flash is "extremely, extremely large," with Pro being significantly stronger on complex tasks.

Cache Hit Rate Optimization: This is the core of cost control. By carefully designing the context structure, the project maintains a cache hit rate above 90%, reaching 95%-98% at peak performance. Cached token prices are far lower than first-computation prices — a massive advantage of DeepSeek's API KV cache mechanism.

KV Cache Mechanism Explained: KV Cache (Key-Value Cache) is a core optimization technique for large language model inference. In the Transformer architecture, the attention computation for each token requires accessing the Key and Value matrices of all preceding tokens. KV caching stores these intermediate computation results to avoid redundant calculations for identical context prefixes. For API providers, when multiple requests share the same context prefix (such as system prompts or project documentation), the server can reuse cached KV states, dramatically reducing computation — and thus charging users lower prices. DeepSeek's cache hit pricing is typically only 1/10 or less of the first-computation price, which is why a 90%+ cache hit rate can compress actual costs to a tiny fraction of the theoretical peak. The key to achieving high cache hit rates is maintaining prefix stability — placing unchanging project documentation and system prompts at the beginning of the context, and putting per-request user input at the end.

Agentic Architecture: Evolution from Prompt to Headerless

The developer described the evolution path of AI application architecture: from Prompt (simple prompting) to Context (context engineering) to Headerless (headless architecture). His project has adopted the Headerless architecture, meaning the AI system can autonomously manage context and schedule tasks without relying on a single conversational entry point.

The Evolution Logic of Headerless Architecture: Headerless architecture originates from web development, where it referred to a design pattern with complete frontend-backend decoupling where the backend only provides API interfaces. In the AI Agent context, this concept has been reinterpreted: the system no longer relies on a single conversational entry point or fixed prompt templates. Instead, the AI system autonomously manages context lifecycles, dynamically dispatches subtasks, and coordinates information flow between multiple Agents. This is fundamentally different from early Prompt Engineering (static prompt design) and Context Engineering (context window management) — both of which still rely on humans to design the interaction structure. Headerless architecture grants the AI system greater autonomy, enabling it to independently decide when to read documentation, which sub-Agent to invoke, and when to terminate a task chain. This architecture aligns more closely with the goals pursued by Agentic frameworks like AutoGPT and LangGraph, representing a paradigm shift in AI engineering from "tool usage" to "autonomous collaboration."

Initialization Flow Design

At each startup, the system reads required documentation and context according to project conventions, consuming approximately 50,000 tokens for initialization. However, thanks to the caching mechanism, this portion almost entirely hits cache, making the actual cost negligible. The entire project supports a 1-million-token context window, with initialization occupying only 5% of capacity.

Multi-Agent Collaboration

The project deploys multiple specialized Agents organized by domain:

• Coding Agent: Responsible for writing code based on design documents
• Review Agent: Performs code quality reviews
• Research Agent: Conducts technical research
• Build Agent: Handles project build-related tasks
• Methodology Agent: Provides architecture and methodology guidance

Simple Agents (like review) use the cheaper Flash model, while deep tasks use the Pro model. After the permanent 75% discount, the developer leans toward "using Pro whenever possible."

The Engineering Value of Multi-Agent Collaboration: Multi-Agent systems decompose complex workflows into subtasks with clear responsibilities, with theoretical foundations in the Separation of Concerns principle from software engineering. This design has several key engineering advantages: First, specialized Agents have shorter, more precise system prompts with more stable context prefixes, resulting in higher cache hit rates. Second, subtasks of different complexity levels can be routed to models of different capability tiers, enabling fine-grained cost-quality balancing. Third, multiple Agents can execute independent tasks in parallel (e.g., simultaneous documentation writing and code review), reducing overall completion time. Microsoft's AutoGen, Anthropic's recommended multi-Agent frameworks, and LangGraph are all exploring this direction, and this developer's practice demonstrates that this pattern is viable in real production environments — not just a laboratory experiment.

Documentation-First AI Development Workflow

The developer emphasized a core principle: You must have AI write documentation first, then code. If you skip documentation and jump straight to coding, "all the design is just floating in the air."

The complete workflow is as follows:

1. Design Document Writing: AI generates detailed design documents based on requirements
2. Code Implementation: AI codes based on the documents
3. Document-Code Comparison Review: AI compares documents and code to check consistency
4. Automated Testing: AI executes test verification
5. Final Human Review: The developer does final confirmation
6. Code Commit

The Deeper Reasoning Behind Documentation-First: This principle isn't new in software engineering — it corresponds to Design-Driven Development. But in AI programming scenarios, documentation-first has additional technical significance: Large language models are fundamentally context-based probabilistic prediction systems. When the context lacks explicit design constraints, models tend to generate "reasonable but inconsistent" code — each invocation may make different implicit design decisions, leading to interface incompatibilities, naming inconsistencies, and other issues across modules. Detailed design documents make these implicit decisions explicit, providing stable "anchor points" for all subsequent AI invocations.