Curson's Viral Internal Plugin Stack Goes Open Source: 9,000 Calls in One Week, Using Engineering Discipline to Tame AI Coding

AI coding tools are falling into a collective anxiety: code output is soaring, but the courage to merge code is declining. A model generates 800 lines of code in one go, but running it reveals countless hidden pitfalls, and review time nearly matches rewriting it yourself. An internal Cursor plugin called Stack attempts to solve this with a set of engineering disciplines—the author's internal leaderboard shows his skills were invoked by colleagues about 9,000 times in a week. After open-sourcing, the community quickly ported it to Claude Code, Codex, GitHub Copilot, and other platforms; one porting repository reached over 2,700 stars and 200 forks in a few months. What did this plugin get right?

What Is Stack: Turning a Senior Engineer's Daily Operations into Markdown

Stack is not a new model, nor a paid SaaS. It's a bunch of Markdown files plus a few scripts, open-sourced under the MIT license. The author, known online as Potato (real name Laurentan), lists Meta and Netflix on his resume, has worked on codebases with millions of lines, later joined Cursor as a Member of Technical Staff, and is also a React core team member involved in maintaining React Compiler. He packaged his entire daily way of writing code in Cursor into a plugin, and his words are blunt: "These are the skills I use every day right now."

The plugin's content is divided into four categories with over twenty workflow skills: 23 task Playbooks covering everything from fixing bugs to running tasks automatically overnight; 24 engineering principles, one per file; and two dedicated subagents. The entire plugin's philosophy is condensed into a single sentence in the first paragraph of the README: "If you want to go fast, go deep first."

Core Mechanism: Potato Mode and Evidence Paranoia

Using it is simple. You don't need to remember the twenty-plus skills—just one command: slash Potato Gun Mode, and write what you want to do in plain language after it. After receiving the task, the plugin automatically matches the corresponding Playbook, copies the steps from the script verbatim into the task list, then calls other skills step by step, dispatching work to subagents. After finishing, it must produce evidence before it is allowed to report completion.

The 23 scripts cover a rich set of scenarios: the bug-fixing script requires reproducing first; if it can't be reproduced, artificially create conditions to force it to appear, then use binary search to locate the root cause. The performance issue script requires running a CPU Trace first and speaking against baseline data. Another script called "Hue Claimed" focuses on continuously optimizing a metric, proposing a hypothesis each round, measuring before-and-after comparisons, and committing only if there is a gain. The most hardcore is the Autopilot script, which verifies and advances a string of PRs one by one along a single line, with a review panel giving conclusions each round.

Multi-model division of labor is another avant-garde design. It doesn't bind to a single model: in the default configuration, coding, feature development, refactoring, and bug fixing are assigned to Grok; decisions requiring judgment and documentation are given to Opus; code review uses a skill called Interrogate, letting models from different families simultaneously review the same Diff and pick at each other. The logic is straightforward—different models have different blind spots, and letting them confront each other leaves far fewer fish slipping through the net.

Subagent and Multi-Model Adversarial Engineering Background

A subagent refers to an independent Agent instance dynamically spawned by the main Agent within a main task flow, dedicated to a subtask. Each instance can be bound to a different model, context, and tool permissions. Stack assigning "writing code" and "making decisions" to different models essentially leverages the current imbalance in large model capability distribution: some models have high throughput and low cost in code generation, while others are more stable in long-context reasoning and judgment. "Adversarial review" borrows from red-team/blue-team confrontation and multi-person review ideas in software engineering—letting models with different training data and different alignment strategies simultaneously review the same Diff can significantly reduce systematic missed detection caused by a single model's training bias. This approach is called "Multi-Agent Debate" in academia, and Stack engineers it into repeatable Playbook steps.

Engineering Principles: Turning "Tacit" Judgment into Textual Assets

The 24 engineering principles are the soul of this plugin. For example, the "Lazy Protocol": prefer deletion, solve problems with minimal changes, subtract before adding, and clear out redundant validators and dead code before starting. "Attack the Premise": if two fixes sharing the same premise both fail, write down the premise and test the premise directly. "Encode Lessons into Structure": if it can be written as a Lint rule, stop writing verbal reminders.

Each of these principles, viewed individually, is commonplace and found in textbooks, but textbooks can't control agents. Writing these tastes into clauses that the agent must reread before every start makes all the difference. This is probably Stack's most valuable aspect: it turns tacit engineering judgment into textual assets that can be distributed and executed.

There is another principle called "Prove It Works": don't treat compilation passing as delivery. Actually run the feature, read out the real values, spread out the Diff, and present verifiable evidence before reporting completion. Another principle, "Explain the Number," specifically treats numerical hallucinations: when the Agent reports a 30% performance improvement, don't believe it first—figure out where the bottleneck actually is, and whether it measured the logic you wanted to measure.

Lint Rules and "Encoding Lessons into Structure"

Lint rules are configurable checks in static code analysis tools (such as ESLint, Clippy) that can detect style violations, potential bugs, and dangerous patterns without running code. The value of turning verbal reminders into Lint rules is that every time the agent generates code, it passes through the same deterministic checks, without relying on it to "remember" a principle. Stack's "Lazy Protocol" and "Attack the Premise" are judgment-level principles that are difficult to fully Lint-ify, but the author still emphasizes that anything that can be structured should not remain in text—because textual principles rely on the model rereading and executing them each time, while Lint is a mandatory gate. This actually corresponds to the trade-off between "convention over configuration" and "automated gatekeeping" in traditional engineering: principles are responsible for direction, Lint for the bottom line.

Anti-Consensus Stances: No Planning, Don't Interrupt Easily

Several anti-consensus stances are hidden in Stack. The entire plugin has no skill for making plans, and the author's explanation is direct: he doesn't believe in planning before acting; the best specification is the code itself. You can make plans—there is a corresponding script in Potato Mode—but it will never be the default action. Another stance is that the Agent should not stop to ask people at every turn. The principle is clear: keep going, present the results afterwards for people to correct, and only irreversible operations require confirmation.

Putting these two together reveals the author's complete argument: leave judgment to the running results and minimize interruptions. Behind this is a complete trust model—most people using agents either trust them completely or watch them constantly; complete trust gets you burned, constant watching wastes the benefit. Stack offers a third path: first let the agent work under strict discipline, producing evidence every time; once enough evidence accumulates, trust has a basis, and only when trust has a basis do you dare to run a second and third agent simultaneously. The author calls this "Fearless Parallelism." The order matters: parallelism is the result, trust is the prerequisite, and discipline is the foundation.

"Fearless Parallelism" and the Agent Trust Model

In traditional multi-threaded programming, parallelism means shared state and race risks; in AI coding, the risk of running multiple Agents simultaneously is that they overwrite each other's modifications, produce conflicting Diffs, or each make decisions based on outdated context. Stack's "Fearless Parallelism" does not encourage blind multi-opening; instead, it treats discipline and evidence as preconditions for parallelism: each Agent works on an independent branch following a Playbook, and when reporting, attaches verifiable evidence (tests passing, Trace data, Diff comparisons). The controller only needs to review evidence rather than watch the process. This actually transplants the continuous integration/continuous delivery (CI/CD) idea from software engineering into Agent collaboration—replacing manual line-by-line watching with automated verification, thereby allowing parallel scale to expand safely.

Community Ports and How Ordinary People Use It

Stack was originally Cursor-exclusive, relying on its internal subagents and plugin mechanism. After open-sourcing, the community responded quickly: someone made a Claude Code port, which also supports Codex, GitHub Copilot, OpenCode, and Gemini CLI. The porter was restrained, explicitly saying Cursor users should use the original directly, and translated Cursor-specific parts one by one into equivalents for the corresponding platforms, retaining all scripts and principles. A plugin that makes users of other platforms actively build bridges is a signal that says more than star counts. Both repositories are MIT, fork freely.

If you don't use Cursor, this stuff is still meaningful. The installation threshold is low, and all platforms now have entry points. Even if you don't use a single skill, just reading through the 24 principles and 23 scripts is like getting a senior engineer's methodology checklist for free—take whichever one strikes you. The most copy-worthy point is that it comes with an "Ultimate Me" skill: it scans your recent chat history with the Agent, analyzes your actual working habits, and generates a dedicated Mode named after you. Potato turned his own taste into a plugin, and at the same time gave you the method to make plugins—your work experience can likewise be沉淀成资产 (precipitated into assets).

The real reason Stack is popular is just one thing: it proves that engineering judgment can be compressed into Markdown, distributed, and executed. The competition in AI coding is shifting from whose model is stronger to whose workflow is more solid.

One-line Summary

Cursor's internal plugin Stack turns engineering judgment into distributable, executable Markdown with 23 scripts and 24 principles.

Paragraph Summary

Stack is a viral engineering discipline plugin from the Cursor team. Author Potato packaged a senior engineer's daily workflow into 23 task scripts and 24 engineering principles, with Potato Mode as a unified entry point that forces the Agent to present verifiable evidence before reporting completion. The plugin uses multi-model division of labor and adversarial review to reduce blind spots, and holds anti-consensus stances: no planning, don't interrupt the Agent easily, and advocate fearless parallelism after building trust through running results. After open-sourcing, the community quickly ported it to Claude Code, Codex, and other platforms, proving that engineering judgment can be compressed into Markdown and distributed for execution.