Can Text‑Driven Vibe Coding Tame Complex AI Infra? A Deep Dive into GPU Time‑Sharing for Agentic RL

Background

Vibe Coding can generate code from conversational prompts, but when applied to large AI infrastructure (tens of thousands of lines of code and hundreds of interdependent decisions) it suffers from three core issues: loss of context, decision drift, and unstable code quality.

Root Cause

The underlying problem is the lack of a persistent, structured decision‑management mechanism. Complex AI infra requires many design decisions (architecture, API design, error handling) that evolve over time, and current conversational programming does not retain or organize these decisions.

Document‑Driven Vibe Coding Methodology

Developers create a structured design document that enumerates every decision point. The document is reviewed and refined collaboratively with AI, ensuring that the AI follows a stable, persistent decision set when generating code. This shifts developers from writing code to focusing on high‑level design.

Case Study: GPU Resource Scheduling for Agentic RL

Agentic reinforcement‑learning workloads exhibit a long‑tail distribution of sample execution times, causing the classic “straggler effect” where the slowest sample blocks progress. Two conventional solutions exist:

Co‑location (serial execution) : All GPUs run rollout first, then training, leaving many GPUs idle during rollout.

Asynchronous separation : Dedicated rollout and training GPU pools run in parallel, but suffer from “dual idle bubbles” when short samples finish early or training waits for new rollout data.

Both approaches leave significant GPU capacity unused.

Time‑Multiplexed Scheduling

The new solution dynamically reallocates GPUs between rollout and training based on workload demand. During rollout low‑demand phases, a subset of GPUs is temporarily assigned to training, and vice‑versa. This leverages the observation that rollout GPU demand fluctuates: high during training completion and low during sampling peaks.

Implementation uses a two‑phase execution flow:

Full‑sampling phase : All GPUs process the majority of samples, driving the system to a low‑demand state.

Scaling phase : The system shrinks the rollout pool, reallocates those GPUs to training, runs training in parallel with remaining rollout work, then expands back for the next iteration.

This dynamic allocation dramatically improves overall GPU utilization while adding only minimal synchronization overhead.

Experimental Evaluation

Experiments were conducted on a 160‑GPU cluster using the Qwen3‑235B‑A22B model and a representative Agentic RL workload. Configuration included up to 100 interaction rounds, 64K token length, batch size 512, and an async ratio of 1. The baseline used a static split (128 training GPUs, 32 rollout GPUs), while the time‑multiplexed scheme used 128 training GPUs and up to 160 rollout GPUs with dynamic reallocation.

Rollout throughput increased by 3.5× compared to the baseline.

Task completion rate improved; the baseline suffered many time‑outs due to limited rollout resources, whereas the time‑multiplexed approach eliminated time‑outs.

System overhead remained low: parameter synchronization across more GPUs added negligible time, and GPU pool scaling operations took only seconds.

Design‑Document‑Driven Development Process

Content Organization : Structure the design document to capture top‑down decisions (architecture, interfaces, variable naming) and break them into hierarchical sections.

Iterative Review : Developers and AI iteratively review each section, ensuring decisions are consistent and documented. The process uses iFlow CLI prompt templates to standardize review steps.

Stepwise Implementation : The document is translated into code in small, dependency‑ordered steps. Each step includes clear validation points and test cases.

Example code generated from the design document includes validation annotations that the AI expands into concrete checks during implementation:

def shrink_sampler(self, target_gpus: List[int]):
    # VAL: VAL_INT_RANGE (min=0, max=7)
    # 将在实施时展开为实际 validation 代码
    offload_ranks = self._calculate_offload_ranks(target_gpus)
    # AST: AST_POSTCONDITION (len(offload_ranks) > 0)
    # 将在实施时展开为 assert 语句
    return offload_ranks

During code generation, the AI expands the annotations, e.g.:

assert len(offload_ranks) > 0, f"Post-condition: offload_ranks not empty, got {offload_ranks}"

Complex validation logic is extracted into dedicated functions (e.g., _validate_gpu_allocation) to keep generated code readable.

System Overhead Analysis

Additional communication for synchronizing parameters across 160 GPUs adds a negligible fraction of total training time. Scaling operations (offloading rollout parameters) take seconds, far smaller than the overall iteration duration, confirming that the performance gains outweigh the overhead.

Conclusion

The document‑driven Vibe Coding paradigm, combined with a time‑multiplexed GPU scheduling strategy, enables AI developers to efficiently build and scale complex infra such as large‑scale Agentic RL systems. It resolves context loss, decision drift, and quality instability while delivering substantial throughput improvements and eliminating rollout time‑outs.

References

ROCK: https://github.com/alibaba/ROCK

ROLL: http://github.com/alibaba/ROLL

iFlow CLI: https://cli.iflow.cn/