He Spent $40 and Burned Through 2 Billion Tokens to Build an Open-Source Package Tracking App with DeepSeek

An Extreme AI-Assisted Programming Experiment

When DeepSeek opened its gray release testing, one developer did something remarkably experimental: spending roughly $40 (300 RMB) and consuming nearly 2 billion tokens, he used AI-assisted programming to build a full-featured, cross-platform package tracking aggregation app called "Yunque (Lark) · Package Assistant."

A few key numbers here deserve explanation. Tokens are the basic units that large language models use to process text — a single Chinese character is typically split into 1–2 tokens, while an English word maps to roughly 1–4 tokens. Consuming 2 billion tokens is equivalent to processing roughly 1 billion Chinese characters' worth of text, encompassing the developer's requirement descriptions, the model's returned code, accumulated multi-turn conversation context, and extensive debugging iterations. The reason $40 could support such massive token consumption comes down to the ultra-low API pricing of DeepSeek's V3 and R1 models, launched in early 2025 — with input token prices as low as approximately 1 RMB (about $0.14) per million tokens, far below competitors like OpenAI's GPT-4o. This price point means LLM APIs have dropped into a range that individual developers can comfortably afford.

Gray release (also known as canary release) is a software deployment strategy where a new version is first rolled out to a small subset of users to monitor stability before gradually expanding. DeepSeek's gray release meant this developer could make large-scale model API calls at relatively low cost during an early stage.

This wasn't just a product development exercise — it was more of a stress test asking: "Can AI independently complete a fully functional app?" Judging by the final result, Yunque is no toy demo, but a practically useful tool with relatively complete features and restrained design.

What Pain Point Does Yunque Solve?

The Fragmentation Problem of Multi-Platform Package Tracking

For most online shoppers, package tracking information is scattered across multiple apps — JD.com, Taobao, Xianyu, Alibaba, and more. Checking a single package often means switching back and forth between several applications. There are deep industry reasons behind this: China's express delivery industry surpassed 170 billion parcels in 2024, averaging over 120 packages per person per year. Major e-commerce platforms each maintain independent logistics tracking systems — JD.com uses a hybrid of JD Logistics and third-party carriers, Taobao/Tmall aggregates courier data through Cainiao Network, and Xianyu relies on Taobao's logistics infrastructure. If users shop across multiple platforms, their package information is naturally fragmented. While aggregation tools like Kuaidi100 and Cainiao existed before, most require users to manually enter tracking numbers or authorize their phone numbers, and data gets uploaded to cloud servers — making privacy risk a persistent core concern.

Yunque's core approach is straightforward: aggregate packages from all platforms into a single app for quick viewing, with automatic deduplication and merging.

The privacy design deserves special attention — all data is stored exclusively on the user's local device, never uploaded to the cloud. In an era of frequent courier information leaks, this is a highly appealing design choice.

AI Deeply Integrated into the Product Experience

Yunque's standout feature is that AI isn't just a superficial "chat box" bolted on — it's deeply woven into core functionality. On the homepage, each package comes with real product images, AI-generated short names, automatically aggregated pickup codes, and AI-predicted arrival times with shipping progress.

Users can directly "Ask Yunque" to rename packages, move them between categories, toggle tracking on/off, and more. In other words, AI here serves as both an information processing engine and part of the interaction layer.

Product Craft in the Details

Detail Pages and Automated Push Notifications

Opening any package's detail page reveals tracking numbers, courier companies, and product information neatly displayed on the product card, with one-tap navigation back to the original order page on JD.com or Taobao. This "aggregated but not disconnected" design avoids the information silo problem common to aggregation tools.

On the automation front, Yunque supports scheduled daily digests — automatically generating and pushing a daily package overview at set times, reducing the burden of active checking.

Smart Desktop Widgets

The desktop widget design is particularly impressive. Widgets automatically rearrange based on the number of packages: from 1 to 24 items, the grid layout adjusts dynamically, font sizes scale with item count, and tapping any cell goes directly to the corresponding detail page. Even with a large number of packages, the interface never becomes cluttered. This kind of content-adaptive layout logic is often where design and engineering coordination is most rigorously tested.

Visual Polish and Developer-Friendliness

Two Themes and Monet Color Extraction

Visually, Yunque offers two themes: one follows the native Android style using Monet color extraction (Material You), where the app's color scheme automatically follows system wallpaper changes; the other is a warm serif-style theme with a cozier, more intuitive feel. Users can also customize colors, fonts, and texture intensity, with separate settings for day and night modes.

Monet color extraction is the dynamic theming system Google introduced in Android 12, officially called Material You — the core feature of the Material Design 3 design language. The system algorithmically extracts primary, secondary, and neutral tones from the user's wallpaper, automatically generating a complete palette with dozens of color steps that are applied across the system UI and apps that support the feature. For developers, implementing Material You support requires using Android's DynamicColors API and replacing hardcoded colors with dynamic color tokens — a task with considerable engineering complexity. This level of design language implementation is quite impressive for an independently developed app.

CLI and MCP: Open Capabilities for Power Users

Yunque also provides two advanced capabilities.

First is a CLI (Command Line Interface) tool — a single command retrieves all package information, making it easy to process via scripts. It's quite rare for a consumer-facing package tracking app to also offer a CLI tool. This means developers or tech enthusiasts can batch-retrieve package data through terminal commands and integrate it into automation scripts. For example, combining it with cron jobs to auto-generate package reports, or using shell scripts to sync package statuses to tools like Notion or Feishu (Lark). This openness toward the geek community exemplifies how indie developer products can differentiate from big-company offerings.

Second is MCP (Model Context Protocol) support. MCP is an open standard protocol proposed by Anthropic in late 2024, designed to establish a unified communication interface between AI models and external data sources/tools. By analogy, MCP is to AI applications what USB ports are to hardware devices — it defines a standardized connection method that allows different AI models to access various external tools and data through the same protocol. In Yunque's case, MCP support means users can invoke Yunque's package querying and status tracking capabilities directly from other AI assistants like Claude or GPT, without needing to open the Yunque app separately. This composability represents the trend of AI applications evolving from isolated tools toward an interconnected ecosystem.

This means Yunque isn't just a closed app — it can become a node in your personal automation ecosystem.

Yunque is now open-source on GitHub. Feel free to download, use it, and submit issues.

Some Observations and Reflections

What makes the Yunque case most thought-provoking isn't that it's some groundbreaking product, but that it demonstrates a new development paradigm: a single developer, aided by a large model like DeepSeek, completed the entire loop — from UI design and feature logic to automated push notifications — at a manageable cost (roughly $40).

Of course, the 2 billion token consumption also reveals that current AI programming still requires extensive iteration and trial-and-error — it's far from the effortless "generate an app with one sentence" scenario. Current AI-assisted programming mainly takes two forms: one is line/block-level code completion represented by GitHub Copilot, providing real-time suggestions as developers write code in their IDE; the other is requirement-driven code generation through conversational models like ChatGPT, Claude, and DeepSeek, where developers describe needs in natural language and the model returns complete code snippets or even files. Yunque's development clearly relied heavily on the latter. The 2 billion token consumption hints at a crucial reality: current AI programming is far from "one-shot generation" — it requires repeated cycles of describe → generate → test → fix. Models may produce logic errors, improper API calls, UI layout deviations, and other issues, with each correction cycle consuming additional tokens. This is why the industry prefers the term "AI-assisted programming" over "AI-automated programming."

But it clearly outlines a trend — the productivity ceiling for individual developers is being dramatically raised. Practical tools that previously required a small team several weeks to build can now potentially be completed by one person plus one model. That is the real signal behind this "$40 experiment."