Cursor Engineer Open-Sources Pstack: A Full Breakdown of AI Coding Workflow Skills

What Is Pstack?

Lauren Tan is a principal engineer at SpaceX, a technical member at Cursor, and also a senior engineer at Meta and a core member of the React team. Recently, she open-sourced her years of accumulated development knowledge, workflows, and principles into a repository called Pstack.

Unlike the common AI coding skill packs on the market, Pstack is not a scattered collection of prompts but a complete skill system built around the AI software development lifecycle. In a video, a Bilibili creator broke it down into six phases: planning, design, build, test, deploy, and maintain, and analyzed the core skills corresponding to each phase one by one.

For developers exploring AI-assisted coding, the value of Pstack lies in showing how a top-tier engineer systematically embeds AI into a real development workflow, rather than stopping at "having AI write a snippet of code."

Breakdown of Core Skills Across the Six Phases

Planning Phase: Learning and Decomposition for Brownfield Projects

Pstack's planning phase clearly leans toward brownfield projects—engineering efforts that already contain a large amount of existing code. It offers two main workflows:

• Learn the code first: Use the help skill to understand how the code works, the why skill to ask why it was designed that way, and then the teach skill to combine the two.
• Decompose large tasks: Use the figure out and show me your work skills to break large tasks into small tickets and record decisions in documents or MD files.

The creator admitted in the video that they would not prioritize Lauren's planning skills, because her design focus is not on building applications from scratch but on large-scale migrations and brownfield transformation. For indie developers or greenfield projects, Matt Pocock's skills or Superpower skills may be more suitable.

Brownfield project is a common term in software engineering referring to engineering work that already has a large amount of existing code and requires further development or transformation on top of it; the opposite is a greenfield project, a brand-new project started from scratch. The core challenge of brownfield projects is that developers must first understand the architecture, conventions, and implicit decisions of the existing code before they can safely add features or perform migrations. This is exactly why Pstack's planning phase includes "learn the code first" skills such as help, why, and teach—they help both AI and developers build a shared understanding of the existing system, rather than jumping straight to writing code.

Design Phase: Multi-Agent Bidding and Aggregation

The design phase has only one workflow: determine the code shape. But the implementation is interesting—the architect skill invokes multiple different models and multiple AI agents, letting each output its own design proposal, then uses the interrogate skill for cross-evaluation, and finally aggregates everything into a unified report.

This differs from the past common approach of "having multiple models each write a version and then manually picking one." Pstack also delegates evaluation and aggregation to AI agents, forming a mechanism similar to competitive bidding. According to the creator's observation, this design is uncommon among previously reviewed skill packs.

Multi-agent refers to an architectural pattern in which multiple independent AI agents each take on different roles or tasks and then aggregate results through some mechanism. Compared with a single call to a large model, the advantage of multi-agent systems is that they can explore multiple solutions in parallel, introduce cross-validation, and reduce the risk of bias from a single model. Pstack's design phase is a typical application of this pattern: the architect skill has multiple models produce design proposals separately, while the interrogate skill plays the role of "reviewer" for cross-evaluation, ultimately aggregating into a unified report. This "generate—evaluate—aggregate" pipeline essentially automates the bidding and review process in software design.

Build Phase: TDD + Type Safety + Removing the AI Smell

The build phase contains two workflows, with test-driven development (TDD) at the core. Pstack's TDD skill differs from those of Matt Pocock and Superpower, and the creator made a dedicated side-by-side comparison, offering selection advice for scenarios such as quick bug fixes, new features, and strict team discipline.

Because Lauren works primarily in the React ecosystem, Pstack also includes a TypeScript best practices skill that forces AI to build applications according to TypeScript conventions. Another notable skill is clean up diff: it checks the diff between the main branch and the current branch, removes excess comments, untyped variables, deep nesting, and other "AI-smelling" code, while running tests to ensure behavior is unchanged, and finally gives a one-to-three-sentence summary.

Why specifically remove comments? The video offers a key insight: AI sometimes prioritizes reading comments over the code itself. If comments do not match the actual code, AI may be misled. Removing comments reduces noise and forces AI to actually read the code.

Test-driven development (TDD) is a development method in which tests are written first and implementation code afterward, usually following a "red—green—refactor" cycle: first write a failing test (red), then write the minimal code to make the test pass (green), and finally refactor the code under the protection of tests. TDD is especially valuable for AI-assisted coding because tests provide a verifiable behavioral contract for AI-generated code and can effectively prevent the problem of AI code that "looks right but does not actually run." Pstack's TDD skill makes scenario-based adjustments on this basis, offering different test granularity and process recommendations for situations such as quick bug fixes, new feature development, and strict team discipline.

Test Phase: From Unit Tests to End-to-End Verification

The test phase has three workflows. The first is proving the application works, using the create verification skill. Its division of labor with the TDD skill is as follows: TDD focuses on functional tests and unit tests, while this skill handles end-to-end testing, requiring starting the application, configuring the database and server, simulating user behavior, collecting evidence, and cleaning up the temporary environment afterward.

There is also a swarm skill that lets multiple AI agents each handle different segments of the end-to-end process and finally aggregate reports, rather than having one agent do everything.

The second workflow is attacking the diff, reusing the interrogate skill from the design phase. It compares code changes between the main branch and the feature branch and lets multiple models try to "break" those changes. There is also a skill called thermonuclear code quality review, which performs an especially strict code quality review and looks for further opportunities for simplification.

Deploy Phase: A Complete Pipeline Around PRs

The goal of the deploy phase is to get features merged smoothly. Pstack provides a set of skills around pull requests: generating easy-to-review PRs, babysitting the entire PR until merge completion, handling merge conflicts (fixed merge complex), fetching the list of PR comments, and fixing CI checks.

The creator points out that PR writing style varies from person to person; Pstack's PR skills can serve as a reference but need not be copied verbatim.

Maintain Phase: Pstack's Gap

In the six-phase model, the maintain phase is the part Pstack does not cover—how to collect issues and feed them back into the planning phase. Lauren did not provide corresponding skills. The creator suggests referring to maintenance-related skills in skill packs such as Superpower to fill the gap.

Auxiliary Skills and Principle Design

In addition to the main workflow, Pstack also has auxiliary skills that can be triggered at any time: router (commonly known as "potato mode"; when you do not know which skill to use, describe the problem and it routes you to the appropriate skill), catch up (quickly review progress after switching context), plain talk (communicate in plain language), as well as writing and continuous improvement skills. The creator particularly recommends catch up and plain talk, considering them very practical when switching between multiple projects.

The design approach of the principles section deserves separate discussion. Lauren did not cram all rules into the system prompt but split them into multiple skills and built an index mapping to trigger them on demand. The reason is straightforward: the system prompt is read with every message, so loading all rules consumes a large number of tokens, and most of the content is irrelevant to the current task.

Regarding specific principles, the creator highlighted three:

• Keep it small: Similar in spirit to the pony tail skill, controlling the scale of changes.
• Attack the premise: When AI repeatedly fixes the same bug but never succeeds, stop and question the assumption—was the direction wrong from the start? The creator said they would add this principle to their own Superpower workflow.
• Type system discipline: Reject impossible states, for example, a payment cannot be both "paid" and "pending" at the same time.

System prompt is the instruction text sent along with messages every time a large model is invoked; the model reads it before generating a response. Because the system prompt must be reprocessed in every round of dialogue, cramming a large number of rules into it continuously consumes tokens and may dilute the model's attention to the current task. Pstack's approach is to split principles into independent skills and then load them on demand through an index mapping—only when a task involves a certain principle is the corresponding skill brought into context. This "index + on-demand triggering" design is consistent with the idea of lazy loading in software engineering, striking a balance between controlling cost and maintaining rule effectiveness.

Key Takeaways

The significance of Pstack is not that it provides a universal set of skills, but that it demonstrates an engineering-minded approach to AI coding: layering by lifecycle, cross-validation with multiple agents, replacing giant system prompts with skill indexes, and turning code quality review into reusable skills.

For teams, its structural design can be borrowed and then tailored to their own tech stack (for example, whether they heavily use React/TypeScript). For individual developers, the creator's advice is also pragmatic—the planning phase can use a skill pack better suited to building from scratch, while the multi-agent aggregation in the design phase, the AI-smell cleanup in the build phase, and the end-to-end verification process in the test phase all have high transfer value.

(Note: The middle of the video contains a sponsor product demonstration unrelated to the Pstack topic, which this article does not cover.)

One-line Summary

Pstack is an AI coding skill system open-sourced by a SpaceX principal engineer, organized around the software development lifecycle.

Paragraph Summary

Pstack is an AI coding skill repository open-sourced by Lauren Tan. Unlike scattered prompt collections, it builds a six-phase skill system around the AI software development lifecycle: planning, design, build, test, deploy, and maintain. The article breaks down the core skills of each phase one by one: the planning phase focuses on learning existing projects and task decomposition; the design phase uses a multi-agent bidding plus aggregation mechanism; the build phase emphasizes TDD, TypeScript best practices, and AI-smell cleanup; the test phase covers end-to-end verification and adversarial review; the deploy phase centers on the PR pipeline; and the maintain phase is a gap. Auxiliary skills and the on-demand triggered principle index design are also worth noting. The article concludes with suggestions for teams and individual developers.