Cursor Engineer Open-Sources Pstack: A Six-Phase AI Coding Pipeline Breakdown

When AI Coding Enters the "Pipeline" Era

A notable trend: more and more senior engineers are starting to "productize" their development methodologies—no longer confining them to blogs or talks, but packaging them directly into AI-executable skills and open-sourcing them. Pstack, recently open-sourced by Lauren Tan—a member of the Cursor technical team and a React core team member—is one of the most systematic examples of this practice.

According to a breakdown video by a Bilibili creator, Pstack covers the complete AI software development lifecycle from planning, design, and build to testing, deployment, and maintenance, distilling her workflow, skills, and principles into a reusable repository. Based on that video's analysis, combined with details across the phases, this article breaks down Pstack's design philosophy and highlights how it differs from other spec-driven frameworks on the market.

The Six-Phase Pipeline: Pstack's Core Skeleton

The creator splits Pstack's skills into six phases, corresponding to the complete AI software development cycle. One premise must be stated first: Lauren Tan's planning-related skills are primarily oriented toward "brownfield" projects (i.e., projects with an existing codebase), excelling at large-scale migrations and legacy modernization rather than greenfield projects starting from scratch.

Phase One: Planning—Understand the Code First, Then Break Down Tasks

The planning-phase skills revolve around "understanding existing code." Use the how skill to learn how the code works; use the why skill to figure out why a piece of code was designed a certain way; the teach skill combines the two into a learning workflow. To break a large task into smaller tickets, use figure out and show me your work, the latter of which records decisions into documents or MD files.

The creator offers a clear personal judgment: for independent developers or those building an app from scratch, he prefers Matt Pocock's or Superpower's skills over Pstack's planning skills. This difference is worth noting—Pstack was never positioned as a "universal scaffold," but as an engineering tool with clear boundaries of applicability.

Phase Two: Design—Multi-Model "Arena"-Style Solution Aggregation

The design phase has only one workflow: settle the code shape. The architect skill triggers an "arena" mechanism that lets multiple different Agents diverge in parallel, each producing a design solution.

Then the interrogate skill steps in, with one model acting as judge to evaluate the solutions and aggregate them into a unified design report. This is fundamentally different from previous skill frameworks that relied on a single model—Pstack builds "multi-model cross-validation" into the design stage, letting models like Opus, GPT, and Grok each propose solutions and then combine their strengths.

Multi-model cross-validation refers to having multiple different large language models (such as Opus, GPT, Grok, etc.) independently answer the same question, then reaching a final conclusion through comparison, voting, or aggregation by a judge model. The principle is that different models differ in training data, architecture, and preferences, so one model's blind spots may be covered by another, thereby improving the robustness of solutions. This approach draws on the idea of ensemble learning—a combination of multiple weak classifiers often outperforms a single strong classifier. In Pstack's design phase, the "arena" mechanism lets multiple Agents diverge in parallel, then a judge model evaluates and aggregates, essentially introducing a "peer review" step into the AI coding workflow to reduce architectural decision errors caused by single-model bias.

Phase Three: Build—TDD as the Foundation, TypeScript Conventions as the Safety Net

The build phase has two workflows. The first is writing code following test-driven development (TDD); the creator previously compared the TDD skills of Pstack, Matt Pocock, and Superpower across scenarios such as quick bug fixes, new features, and strict team discipline. The second is a TypeScript best-practices skill, directly related to Lauren Tan's React background—the React ecosystem is predominantly TypeScript, and this skill forces AI to write code according to TS conventions.

There's another easily overlooked detail: the clean up diff skill compares the main branch with the current branch, cleans up redundant comments, untyped variables, deep nesting, and other issues, runs tests to verify while keeping behavior unchanged, and finally outputs a one-to-three-sentence summary.

Here's an intriguing design—the no comments skill, which actively removes comments from code. The reason is that AI sometimes reads comments before reading code: if a comment says a function returns A but the actual code returns B, the AI may be misled by the comment. Removing comments is essentially "denoising" for the AI, forcing it to confront the real code.

TDD (Test-Driven Development) is a programming practice that starts with tests: developers first write a failing test describing the desired behavior, then write just enough production code to make the test pass, and finally refactor and optimize. Its core loop is called "red-green-refactor"—red means the test fails, green means the test passes, and refactor means improving code structure without changing behavior. In AI coding scenarios, TDD's value is further amplified: test cases provide AI with clear, verifiable goals, giving AI-generated code an objective standard to meet rather than relying solely on the model's "feeling" of correctness. Pstack makes TDD the default workflow of the build phase precisely to use tests as an "acceptance guardrail" for AI coding, reducing the probability of hallucinated code slipping into the main branch.

Phase Four: Testing—From Unit Verification to Multi-Agent "Siege"

The testing phase has three workflows. The first is the create verification skill, which differs from TDD in that it focuses on end-to-end testing: setting up the environment, creating a database, starting services, simulating user behavior, collecting evidence, and finally cleaning up temporary resources. The video specifically emphasizes the organizational rule of "one feature, one folder" rather than cramming all features into the same directory.

Next is the swarm mechanism: instead of having a single Agent run the entire process, multiple Agents (optionally different models) each handle a small portion, and the results are aggregated into a single report. The third workflow, attack the diff, reuses the interrogate skill from the design phase, letting multiple models "attack" the diff between the main branch and the feature branch to see if they can find flaws. Combined with a "nuclear-grade" code quality review layer called thermonuclear code quality review, it further asks whether the code can be simpler.

Phase Five: Deployment—Treating the PR as Something to "Babysit"

Deployment-phase skills revolve around the Pull Request: generating an easy-to-review PR, babysitting the entire PR until it's mergeable, handling merge conflicts (fix merge conflict), pulling a list of review comments, and fixing CI/CD pipeline checks.

The creator also points out a practical issue: how a PR is written varies from person to person, and Lauren Tan's skills can only serve as a reference; teams still need to develop their own style.

Phase Six: Maintenance—The Deliberate Gap

The maintenance phase has no corresponding skills in Pstack, and the creator believes this is exactly where other frameworks (such as Superboard's collect skill) can fill in, forming a closed loop of "collect issues → return to planning."

Brownfield vs. greenfield is a commonly used metaphor pair in software engineering. A greenfield project refers to entirely new development starting from scratch, unconstrained by existing code; a brownfield project refers to continued development, modification, or migration on an existing codebase, requiring understanding of existing logic, compatibility with historical decisions, and control of change risk. The skill needs of the two differ significantly: greenfield projects rely more on rapid scaffolding and from-scratch planning capabilities, while brownfield projects emphasize code comprehension, impact analysis, and incremental refactoring. Pstack's planning skills are explicitly oriented toward brownfield scenarios, which explains why it places "understanding the code" (the how/why skills) at the core of the planning phase rather than providing generic project initialization templates.

Secondary Skills and Principle Skills: Always-Available "Plug-ins"

Beyond the six-phase backbone, Pstack also provides a set of secondary skills that can be triggered at any time. When you're not sure which skill to use, you can launch potato mode, describe the problem, and it will route you to the appropriate skill. There are also skills such as setup, catch up, plain talk, and writing. The creator particularly recommends catch up and plain talk: when switching between multiple projects and contexts, they're very useful for quickly recalling progress.

Principle skills (principles) answer a good question: why not write these rules into the system prompt? Because cramming everything in would make every conversation carry a massive number of tokens, most of which are irrelevant to the current task. Pstack's approach is to split principles into multiple skills and maintain an index indicating when to trigger each one.

The creator picks out two of the most valuable principles. The first is attack the premise: when AI gets stuck in a death loop of "fix bug → fail → fix again → fail again," stop and question the premise—did we go in the wrong direction from the start? The second is "reject impossible states" from type system discipline: a payment cannot simultaneously be "paid" and "pending"; use the type system to block such illegal states at the door.

Pstack's Positioning from Multiple Perspectives

From the video author's horizontal comparison, the division of labor between Pstack and frameworks like Matt Pocock and Superpower is fairly clear: Pstack is strong in understanding existing code and large-scale refactoring, multi-model arena-style solution design, and aggressive testing; it is weak in greenfield project planning and the maintenance closed loop. This is not a defect but a design orientation. For teams, the more pragmatic approach is to take the best of each—incorporating principles like attack the premise and "reject impossible states" into your own skill library rather than copying everything wholesale.

Key Takeaways

• Pstack is an AI coding skills repository open-sourced by Lauren Tan, covering six phases: planning, design, build, testing, deployment, and maintenance.
• The design phase uses an "arena" mechanism of multi-Agent parallel divergence plus judge-model aggregation, fundamentally different from single-model approaches.
• The no comments skill actively removes comments to prevent AI from being misled by incorrect comments, forcing it to read the real code.
• Principles are not written into the system prompt but split into skills plus an index to control token overhead and trigger on demand.
• Its boundaries of applicability are clear: it excels at brownfield projects and large-scale refactoring, while greenfield planning and the maintenance closed loop can be supplemented with other frameworks.

One-line Summary

Pstack breaks AI coding into a six-phase pipeline, forming an engineering closed loop with a multi-model arena and a principle skill library.

Paragraph Summary

Based on a Bilibili creator's breakdown video, this article systematically reviews Pstack, the AI coding skills repository open-sourced by Lauren Tan—a member of the Cursor technical team and a React core team member. Pstack breaks AI software development into six phases: planning, design, build, testing, deployment, and maintenance. In the design phase, it introduces an "arena" mechanism of multi-Agent parallel divergence plus judge-model aggregation; in the build phase, it relies on TDD and TypeScript conventions as a safety net; and through the no comments skill, it actively removes comments to prevent AI from being misled. Its principle skills are not crammed into the system prompt but split into skills plus an index to control token overhead. The article also points out Pstack's boundaries of applicability: it is strong in brownfield projects and large-scale refactoring, but weak in greenfield planning and the maintenance closed loop, suggesting teams take the best of each rather than copying everything wholesale.