OxygenData-Vibe: Redefining Dashboard Development with AI Coding
OxygenData-Vibe lets business users create custom data dashboards through natural language conversations with an AI agent, cutting delivery from 30 person-days to 3 days by decoupling complex BI query logic from AI-friendly frontend generation via a two-phase architecture with AST-based error correction and a custom CodeSandbox for instant preview.
Problem: BI Tools vs. Custom Development
Traditional dashboard development faces a trade-off: standardized BI tools deliver fast (1 day) but limit chart styles, interactions, and extensibility; custom development meets complex needs but costs heavily (30 person-days per dashboard). Products like Alibaba's Business Advisor and ByteDance's E-commerce Compass invest heavily in custom builds to surpass BI boundaries. The core question: can we combine custom flexibility with BI-like efficiency?
AI Coding Practice & OxygenData-Vibe Concept
In H1 2024, the retail data engineering frontend team applied AI Coding to custom dashboard projects, achieving >90% AI-generated code. This raised a further question: can business users bypass developers entirely and generate dashboards via natural language? OxygenData-Vibe was born: users configure datasets, then describe needs in natural language; an Agent converts ideas into runnable, iterable, publishable dashboards — no fixed charts, no developer dependency, continuous dialogue shapes the dashboard.
Results Since September Launch
478 AI Coding dashboards created
117 published and in production use
Delivery reduced from 30 person-days to 3 days for initial version
User Workflow: Three-Step Demo
Step 1: Describe Business Intent
Users state analysis goals or import requirement documents. The Agent uses intent and real datasets to autonomously build the dashboard; business language is the starting point.
Step 2: Real-Time Preview
Generated dashboard appears on the right side immediately after development.
Step 3: Continuous Iteration via Dialogue
Layout, colors, charts, interactions — all adjustable via natural language (e.g., "beautify the style"). The Agent understands context and iterates on the current artifact.
Core Challenge: Dynamic Dashboard Complexity
Dynamic query dashboards (real business apps) are 10×+ more complex than static dashboards (demos). Key differences:
Overall Complexity : Static 1× (baseline) vs Dynamic 10×+
Data Scale : Static ≤ hundreds of thousands rows vs Dynamic tens to hundreds of millions rows
Data Understanding : Static AI reads full local data vs Dynamic AI relies on schema/samples, cannot fully grasp real data
Business Rules : Static anomalies/rules easier to spot vs Dynamic dirty data, hidden rules, complex metric definitions
Development Mode : Static generate HTML with fixed data vs Dynamic generate query DSL, dynamic params, data APIs, frontend interactions
Filter Interaction : Static local filtering, simple logic vs Dynamic filter changes require query reconstruction and data fetch
Data Validation : Static full Excel cross-check vs Dynamic must verify across time, filters, data changes
Multi-Source : Static usually single Excel vs Dynamic multiple dataset types, non-uniform query/access
Industry Solutions : Static relatively mature vs Dynamic still exploratory, no mature pattern
Example: switching time range from "all" to "last year" and selecting "East China" triggers re-identification of filters, granularity adjustment, YoY period calculation, per-chart query construction, null/anomaly handling, and rendering. Any deviation yields a "plausible but wrong" result.
Two Failed Paths
Static AI Coding mode : send data directly to AI. BI datasets reach hundred-million scale; context limits make this infeasible.
Traditional custom mode : give AI BI query API docs. Query protocols (filters, YoY/MoM, comparative analysis) are too complex; data correctness unguaranteed.
Conclusion: dynamic dashboards cannot copy static AI patterns nor hand complex queries to LLMs. A new architecture must prioritize generation efficiency and data reliability.
Design Philosophy: "AI-Friendly Universe"
Recognize AI limitations: private-domain knowledge (LLMs untrained on internal BI protocols; RAG has token limits and hallucination; Claude Code doesn't use RAG) and high business-rule complexity.
Instead of teaching AI internal rules, redesign the world AI sees — make what it must understand fewer and more generic. Transform internal proprietary knowledge into generic expressions LLMs already know from training (code, tech docs, common knowledge).
In traditional BI, AI generating a YoY metric must understand period, time field, alignment, formula; for a tree filter, it must grasp multi-level AND/OR nesting and hand-craft complex params. These are BI-specific rules where AI errs most.
In the new architecture, complex rules are absorbed by query and component layers before AI development. From AI's perspective, three shifts occur:
No private business rules in development : YoY period determination, metric aggregation, filter nesting — not passed as background knowledge or interface docs. AI faces a stable generic protocol.
Request params become simple filter values : AI no longer builds complex query DSL; only passes filter fields and user-selected values. Tree filter AND/OR nesting, permission conditions, dataset-specific params auto-completed by components/query layer. For AI, a query is just "which data module, with which filter values".
Response results become plain fields : YoY, MoM, share, cumulative — all computed in query layer, returned as ordinary fields. E.g., sku_total_yoy_rate and sku_total are indistinguishable to AI: both have clear name, type, meaning, bindable to KPI cards, charts, tables.
Summary: Development side: no private knowledge; Request side: simple filter values; Response side: plain data fields. BI expertise doesn't disappear — it sinks into query/component layers as stable system capabilities, no longer requiring AI to relearn per page.
Architectural Decoupling: Two Phases
Phase 1: Query Protocol Construction (Human-AI Collaboration)
Handles datasets, metrics, dimensions, filters, complex BI query rules — not fully AI-friendly. Uses GUI human-AI collaboration: AI assists understanding/generation; platform GUI and human judgment provide constraints/confirmation; produces accurate, standardized query protocols.
GUI collaboration capabilities: chart data source config, SQL inspection, etc.
Phase 2: Page Building on AI-Friendly Protocol
Query complexity isolated in Phase 1. AI now sees a semantic, stable, easy-to-call protocol. Focuses on layout, chart expression, interaction implementation — efficiently turning business intent into final dashboard.
Key: not forcing AI to master all rules, but first using human-AI collaboration to convert complex queries into AI-friendly protocols, then letting AI create pages. Preserves query accuracy while unleashing AI creativity.
Concrete JSON Protocol Examples
Example 1: YoY Rule → Plain Metric Field
Phase 1 query protocol (specifies base metrics, comparison method, output type, time filter ref):
{
"ref": [
"sku_total",
"tag_enum_total",
"gmv_total",
"sale_qty_total",
"brand_total"
],
"derive": {
"transform": "periodCompare",
"compare": "yoy",
"output": "rate",
"dateRef": "dateFilter"
}
}Meaning: using dateFilter as time base, apply periodCompare transform, compute yoy, output as rate. Period alignment, same-period data fetch, rate calculation handled by query layer.
Phase 2 response converts derived metrics to plain fields:
{
"response": {
"rows": {
"type": "array",
"item": {
"sku_total_yoy_rate": {
"type": "number",
"role": "measure"
},
"tag_enum_total_yoy_rate": {
"type": "number",
"role": "measure"
}
}
}
}
}Now sku_total_yoy_rate is just a normal numeric measure. AI binds directly to KPI card/chart without knowing YoY period derivation, dual-period alignment, or implementing YoY calculation in page code.
Example 2: Tree Filter Component Auto-Generates Complex Query Conditions
Phase 2: AI only declares filterable fields and operators:
[
{ "name": "a1", "op": "in" },
{ "name": "a2", "op": "in" }
]When user selects "a1 in (2,3)" OR ("a1 = 11" AND "a2 in (11,22,33)"), frontend tree filter component auto-generates actual query protocol:
{
"type": "or",
"children": [
{ "a1": [2, 3] },
{
"type": "and",
"children": [
{ "a1": 11, "a2": [11, 22, 33] }
]
}
]
}AI only declares "which fields can be filtered"; component translates user actions into query tree with AND/OR/nested children. Reduces AI protocol errors and avoids re-explaining low-level query rules during page building.
Technical Architecture: Three Pillars
0. Data Profiling: "Understand Data Before Building"
Inspired by Claude Code + Excel → HTML: Claude first inspects schema, analyzes dimension values, metric distributions, then decides fields, aggregations, charts. Static dashboards work well because of "understand data first".
Dynamic datasets have tens/hundreds of millions rows — cannot feed all to LLM. Solution: dataset profiling — fetch field metadata, statistical features, sample rows, dimension enums, supported query methods, permissions, field combinability. Output: a "data map" for AI, not raw data.
1. Turn Data Queries into AI-Understandable APIs
Page dev doesn't start with code. First answer: what data can this page query, what filter values can it accept, what fields will it return?
Captured in data-modules.json — dashboard design spec: each data module's dataset, metrics, dimensions, filters, derived calculations, sorting, drill-down, aggregation. AI + user configure via GUI; objective field names/types pulled from dataset metadata, no model guessing.
After structural, dataset, and online combination validation, compiled to api-wiki.json. Each Data Module becomes a clear API: which queryId to call, allowed filter values, pagination/sorting support, and response.rows.item fields. API Wiki is a compilation artifact, not a manual doc. Complex BI rules stay in Data Module; AI receives only a simple interface contract: request with plain filter values, consume plain fields — even if a field is YoY/MoM behind the scenes, AI just sees name, type, meaning.
2. Frontend UI Development
2.1 Code Generation
Agent receives business requirements + API Wiki, plus page templates, component specs, business cases, UI guidelines. From params knows available filters; from response knows chart-usable fields — no direct touch of low-level BI protocol.
Pipeline orchestrated by Skills: clarify requirements → prepare query protocol → generate code → check errors → package preview → publish. AI retains freedom on look, chart choice, interactions; but each step's inputs, tools, completion criteria are explicit.
2.2 Custom AST Loop: Locate & Fix Errors
Compilable code ≠ correct dashboard. Model may invent non-existent queryId, mismatch filter fields with API Wiki, misuse query params or components. Syntax-legal but runtime-fatal; standard Lint misses these.
Solution: TypeScript Compiler API-based AST Checker. Analyzes source AST + module dependencies, applies domain rules (query, filter, table, runtime) + TypeScript type checking. Knows not just "code legal" but "fields/queries/components conform to API Wiki & platform specs".
Runs after every generation round. Checker pinpoints file + code location, gives explicit reason. Agent fixes, re-checks. Loop: Generate → Detect → Locate & Fix → Re-check until all rules pass. Additionally, spec-check validates project structure/delivery specs at dev and package stages. Former ensures correct platform capability usage; latter ensures artifact meets delivery standards. Together they converge model output into runnable pages.
3. Packaging & Runtime: Custom CodeSandbox
Traditional frontend: install node_modules, start Node dev server — unsuited for online Agent. Dependency install fragile (network, registry, lockfile, env differences), causing instability and non-reproducible results.
Custom CodeSandbox: places Agent-generated files in in-memory virtual FS, uses esbuild for runtime module resolution, compilation, bundling. React, chart libs, EasyBI etc. loaded from pre-built CDN. No node_modules install — code runs immediately after generation.
Benefits:
Time savings: env setup from ~10 min to near zero; bundling from minutes to seconds.
Consistency: unified CDN vendor + single runtime eliminates dependency drift; dev, preview, publish share identical env.
Workflow: dev → sandbox preview (hot reload via Dev Server); publish → same build compiles to IIFE, assembles with runtime deps into standalone HTML; HTML + source archived to CDN, registered in EasyBI.
For Agent: "install deps → start server → local build" becomes "generate code → second-level compile → sandbox run". Shorter feedback loops enable more generate/verify/fix cycles in same time, stabilizing online development.
Conclusion
Under rapid AI Coding evolution, dashboard production is shifting. Previously: configure within BI presets or hand to developers. Now: users articulate analysis thinking; AI turns requirements into pages. Dashboard capabilities no longer bounded by BI presets or dev headcount, but driven by business needs. This boosts efficiency and enables high-experience demands previously infeasible. Since September launch, 478 dashboards created via OxygenData-Vibe, 117 published and in use — proving the approach solves real needs.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
