Vibe Coding in Practice: How Four Tools Work Together to Make AI Programming More Convergent and Controllable

AI Programming Is More Than Just Cursor and Claude Code

As Vibe Coding becomes increasingly popular, many programmers focus their attention on code generation tools like Cursor and Claude Code, overlooking a critical question: How do you make AI-generated code more convergent and controllable?

The concept of Vibe Coding was coined by Andrej Karpathy—former AI Director at Tesla and co-founder of OpenAI—in February 2025. It describes an entirely new programming paradigm: instead of writing code line by line, developers describe desired functionality to AI in natural language, let the AI generate the code, and then simply review, adjust, and accept the results. Karpathy himself described the experience as "fully immersed in the vibes, embracing exponential growth, and forgetting that code even exists." The concept quickly sparked widespread discussion in the developer community because it fundamentally redefines what "programming" means—shifting from "writing code" to "managing AI as it writes code."

Bilibili creator "Code Corporation" (码士集团) shared during a livestream the four-tool collaboration system he uses in real-world development, offering a methodology worth studying for engineering-grade AI programming practices.

He also raised a thought-provoking question: Will large model engineers themselves be replaced by AI? His answer: "It's possible, but definitely not right now."

Two Overlooked Prerequisite Tools: SuperPrompt and Gstack

Most developers doing AI-assisted programming jump straight into Cursor or Claude Code and start writing code. Cursor is an AI-native code editor developed by Anysphere, deeply rebuilt on top of VS Code with built-in AI capabilities including code completion, multi-file editing, and natural language chat. It has rapidly become one of the most popular tools in AI programming since 2024. Claude Code is Anthropic's command-line AI programming tool, powered by the Claude large model, capable of understanding an entire codebase's context directly in the terminal to perform code writing, debugging, refactoring, and more. Both tools emphasize "code generation" capabilities, but they are fundamentally execution-layer tools—great at generating code based on instructions, but not responsible for deciding "what code should be generated" or "how different pieces of code should work together."

However, Code Corporation points out that a truly efficient AI programming workflow requires introducing two key tools before code generation: SuperPrompt and Gstack.

These two tools address problems at different levels:

• SuperPrompt: Handles macro-level project decomposition, playing the role of "architect"
• Gstack: Handles micro-level code layering, serving as the "tech lead"

Their existence essentially introduces "architecture design" and "task management" stages into the AI programming workflow, rather than dumping everything onto the code generation model to figure out on its own.

SuperPrompt: A Project-Level Workflow Decomposition Engine

SuperPrompt's core purpose is to generate a complete development workflow for an entire large project. Its design philosophy stems from the classic "divide and conquer" approach in software engineering and the requirements analysis phase in waterfall/agile development. In traditional development, a large project typically goes through requirements analysis, architecture design, technical review, and other stages before any coding begins. SuperPrompt essentially automates these stages—it leverages the reasoning capabilities of large models to transform a vague project description into a structured development plan. This "plan first, execute later" pattern is known in the Prompt Engineering field as an engineering application of Chain-of-Thought: rather than asking AI to solve a complex problem in one shot, you first have the AI break the problem into manageable subtasks, then tackle them one by one.

Specifically, it helps developers accomplish the following:

• Feature module decomposition: Breaking a complex project into several major functional modules
• Requirements refinement: Clarifying the specific requirements for each module
• Module integration design: Defining interfaces and integration patterns between modules
• Test strategy planning: Determining when to run unit tests and when to run integration tests
• Code generation workflow: Establishing a standardized process for each code generation cycle

In simple terms, SuperPrompt plays the role of "project manager" or "architect." Its output isn't code—it's a structured development workflow that gives subsequent code generation a clear roadmap to follow.

Gstack: Module-Level Code Layering and Boundary Definition

Gstack operates at a finer granularity. Its purpose is to take any given module within a project and perform code-level decomposition and layering.

Layered Architecture is one of the most fundamental architectural principles in software engineering. Common layering patterns include MVC (Model-View-Controller), three-tier architecture (presentation layer – business logic layer – data access layer), hexagonal architecture, and more. The core purpose of layering is to achieve Separation of Concerns, ensuring each layer handles only specific responsibilities and communicates with other layers through well-defined interfaces. In AI programming scenarios, if layering rules aren't defined in advance, AI-generated code often falls into anti-patterns like "God Class" or "Spaghetti Code"—all logic tangled together, making it difficult to maintain and extend. By defining layering rules and module boundaries before code generation, Gstack prevents these architectural degradation issues at the source.

Specifically, Gstack provides the following core capabilities:

Code Decomposition and Layering

For any sub-feature within a functional module, Gstack further breaks it down into smaller code units and defines a clear code hierarchy. This prevents the problem of AI generating large amounts of tightly coupled code in one go.

Boundary and Rule Definition

This is one of Gstack's most valuable features. Developers can define within Gstack:

• Code preferences: Such as coding style, naming conventions, framework choices, etc.
• Convergence rules: Constraining the AI's output scope to make results more controllable
• Code boundaries: Clearly defining each module's responsibility boundaries to prevent scope creep

It's worth diving deeper into the concept of "code convergence." When large language models generate code, they're fundamentally performing token prediction based on probability distributions, which means the same requirement can produce code outputs with vastly different styles and structures. As project scale grows, this uncertainty leads to serious engineering problems: inconsistent naming conventions across modules, chaotic architectural patterns, conflicting interface definitions, reinventing the wheel, and more. "Making code more convergent" means using external constraints to narrow the AI's output space, so it generates code with unified style and consistent structure within a predefined framework.

This directly answers a common frustration among developers—how to make AI-generated code more convergent. The answer isn't to pile more constraints into your prompts, but to use dedicated tools to systematically manage these rules and boundaries.

The Four-Layer Collaboration Architecture: Making AI Programming Truly Engineering-Grade

Connecting all four tools reveals a clear layered collaboration architecture:

Layer	Tool	Responsibility
Project Layer	SuperPrompt	Overall workflow planning, module decomposition
Module Layer	Gstack	Code layering, boundary definition, rule setting
Execution Layer	Cursor / Claude Code	Actual code generation

SuperPrompt and Gstack essentially "supervise" the work of code generation tools. They provide contextual constraints and structured instructions, allowing Cursor and Claude Code to operate within a well-defined framework rather than generating code with unchecked creative freedom.

The design philosophy of this toolchain aligns closely with the industry evolution trends in AI programming tools during 2024-2025. The entire industry is moving from simple "code completion" toward comprehensive "development workflow orchestration." GitHub Copilot pioneered the AI code completion space, followed by Cursor, Windsurf, Claude Code, and others expanding capabilities to multi-file editing and project-level understanding. The emergence of tools like SuperPrompt and Gstack represents the industry's next evolutionary direction—the "middleware layer" of AI programming. Similar trends include: Devin (AI software engineer) attempting end-to-end automated development, OpenAI Codex offering asynchronous code generation capabilities, and various AI Agent frameworks attempting to orchestrate programming tasks into multi-step workflows. The industry is forming a consensus: raw code generation capability is no longer the bottleneck—how to orchestrate and manage AI workflows is the key differentiator.

Code Corporation also mentioned an alternative approach: skip SuperPrompt and Gstack entirely, have the developer personally handle project decomposition and task breakdown, then manually supervise the AI as it generates code in small increments. This approach works, but it essentially replaces tooling with manual labor, resulting in a noticeable efficiency gap.

Will Large Model Engineers Be Replaced by AI?

Returning to the opening question, Code Corporation offers a measured assessment: It's possible, but definitely not right now.

The logic behind this judgment is clear—based on current AI programming practices, even with powerful code generation capabilities, architecture design, task decomposition, rule definition, and quality control still require human involvement. The very existence of tools like SuperPrompt and Gstack demonstrates that AI programming is still quite far from being "fully automated."

From a broader perspective, the layered structure of today's AI programming toolchain—planning layer, design layer, execution layer—itself mirrors the classic division of labor in software engineering: "architect – tech lead – developer." AI can currently handle execution-layer work reasonably well, but at the planning and design layers, it still heavily depends on human judgment: understanding business requirements, weighing trade-offs between technical approaches, and anticipating system complexity—capabilities that are unlikely to be fully automated in the near term.

What's truly valuable isn't being someone who can write code, but being someone who knows how to decompose problems, define boundaries, and manage AI workflows. This is perhaps the core competitive advantage for programmers in the age of large models.

Conclusion: Mastering the Workflow Is the Core Competitive Advantage

For developers currently practicing AI programming, the recommendation is to look beyond code generation tools like Cursor or Claude Code alone, and instead build a complete tool collaboration system. From project planning (SuperPrompt) to module design (Gstack) to code generation (Cursor/Claude Code), each stage has corresponding tools to boost both efficiency and quality.

The future of AI programming belongs to engineers who can master the entire workflow.