Breaking Down PStack: A Cursor Engineer's AI Coding Skills Library and Workflow

Title

Breaking Down PStack: A Cursor Engineer's AI Coding Skills Library and Workflow

Meta Description

An in-depth breakdown of PStack, the open-source AI coding skills library from Cursor engineer Lauren Tan: a six-stage development lifecycle, multi-model collaboration design, TDD and end-to-end verification, on-demand loading of principle skills, and how it differs from MapPocock and Superpowers.

Article Content

AI coding tools are evolving from simple code completion toward systematic skills libraries. Recently, Lauren Tan—an engineer who has worked at SpaceX and Meta and was a member of the React core team—organized her accumulated knowledge workflows and development principles into an open-source repository called PStack. What skills does this toolkit actually include? How does it differ from the familiar frameworks like MapPocock and Superpowers? Based on a detailed breakdown video from a Bilibili creator, this article walks you through PStack's six-stage workflow and core design philosophy.

What Is PStack: An AI Development Operating System for Existing Projects

PStack is not a project scaffold for starting from scratch. Its core positioning is to serve so-called "Brownfield projects"—existing projects that already have a codebase. Lauren Tan organizes skills into six stages, corresponding to a complete AI software development lifecycle: planning, design, build, test, deploy, and maintain.

What makes this repository unique is that it doesn't try to cover every scenario. Instead, it focuses on the high-frequency pain point of "continuing development on top of an existing codebase." For indie developers or those who want to build a brand-new app from scratch, the Bilibili creator admits they prefer the skills from MapPocock or Superpowers; but if you're facing a large-scale migration or complex system adjustments, PStack's planning skills are spot on.

Breaking Down the Six-Stage Workflow: From Understanding Code to Safe Delivery

Planning and Design: Understand First, Then Let Multiple Models "Race"

In the planning stage, PStack offers two workflows: understanding existing code, and planning a large task. If you want to know how the code works, use the How skill; if you want to understand the design rationale, use the Why skill; Teach combines both, explaining both how it works and why. If you need to break a task into tickets, Figure It Out together with Show Me Your Work can record decisions into formal documentation.

The highlight of the design stage is "determining the shape of the code." The Architect skill invokes multiple different AI agents, letting them each develop a design and produce their own implementation plans. Then the Interrogate skill has models evaluate these plans, compare the results, and synthesize them into a complete design report. This is completely different from most frameworks that rely on a single model for answers—you can have Opus, GPT, and Grok each run a round of design, then pick the best parts from each model and integrate them.

Brownfield vs. Greenfield: In software engineering, a Greenfield project refers to brand-new development starting from scratch with no legacy baggage; a Brownfield project refers to continuing to evolve on an existing codebase, requiring compatibility with existing architecture, dependencies, and business logic. The latter often faces challenges such as high comprehension costs and high change risk, and PStack is positioned precisely to systematically address such scenarios.

Multi-model "racing" mechanism: This refers to calling multiple different large language models (such as Opus, GPT, Grok) in parallel to independently generate plans for the same design task, then using evaluation skills to compare strengths and weaknesses and integrate the best parts. This mode leverages diversity among models to reduce the risk of bias from a single model, but it increases token consumption and coordination complexity—suitable for critical decisions that demand high design quality.

Build: TDD First, Clean Up AI-Style Code

The build stage prepares two workflows. The first is writing code according to test-driven development, handled by the TDD skill. The Bilibili creator previously compared the TDD skills of PStack, MapPocock, and Superpowers: quick fixes for small issues, developing new features, or working in a discipline-focused team each call for different choices. TDD is also paired with a TypeScript best practices skill, because Lauren Tan mainly focuses on React development, and React is deeply tied to TypeScript.

The second is cleaning up code diffs. The Deslop skill compares the main branch with the current branch and checks whether the changes contain redundant comments, unnecessary Try Catch blocks, variables lacking explicit types, and overly deep nesting. There's a key design here: PStack has a dedicated No Comments skill that emphasizes writing fewer comments. The reason is straightforward—AI sometimes reads comments directly without carefully looking at the actual code. If a comment says a function returns A but the implementation returns B, the AI may fixate on the comment and treat it as fact. Removing redundant comments is about making the AI actually look at the code itself.

Test-Driven Development (TDD): A development method where tests are written first, then implementation code, using the "red-green-refactor" cycle to ensure code always has test coverage. In AI coding scenarios, the TDD skill requires the AI to first generate failing test cases based on requirements, then write implementations that pass the tests, thereby constraining the AI from deviating from the goal.

AI-style code: Refers to redundant patterns commonly found in AI-generated code, such as overly defensive Try-Catch blocks, uninformative comments, vague type declarations (like any), and unnecessary deep nesting. Although this code runs, it reduces readability and maintainability. The Deslop skill automatically identifies and cleans up such issues by comparing branch diffs.

Test: End-to-End Verification and Multi-Agent "Attacks"

The test stage has three workflows. The first is proving the app actually runs, corresponding to Create Verification Skill. Its difference from TDD is that TDD focuses on functional tests and unit tests, while this skill focuses on setting up an end-to-end verification environment—the database needs to be configured, the server needs to be started, dependencies need to be in place, and the whole environment needs to run the way a real user would use the app. When problems arise, diagnose them, collect evidence, and then clean up the environment.

The second is Swarm, which lets a group of agents divide the work. You don't have to have the same agent run the entire process alone; you can have multiple agents each handle different pages, and you can even choose different models for each agent, finally aggregating everything into a report.

The third is actively attacking this change. The Interrogate skill appears again: first compare the main branch with the feature branch to identify the scope of changes, then have different models try to break the changes from different angles to find weak points. There is also a skill called "hot-fix-level code quality review," which is like adding an extra layer of exceptionally strict review, asking whether the code could be written more simply—similar in spirit to the Ponytail skill.

Deploy and Maintain: Covering the Entire Delivery Chain

The deploy stage handles merge requests. The first step is making PRs easier to review, but every team has its own writing style, so how to write a PR still depends on your preferences. There are also follow-up skills like BabySit that keep an eye on merge requests until they are confirmed merged, skills to fix merge conflicts, and skills to fetch PR review comments, list comments, and fix CI pipeline checks.

In the maintenance stage, PStack doesn't have a dedicated skill for "bringing issues back to the planning stage." The Bilibili creator points out that this gap can be filled with maintenance skills like SuperCollab from Superpowers, which was reviewed earlier.

Automated PR (Pull Request) review: PStack's deploy stage includes skills for fetching PR comments, listing to-dos, and fixing CI pipeline failures, aiming to hand repetitive work in code review and the merge process over to AI agents. The BabySit skill can continuously monitor PR status until merge, reducing manual polling costs.

CI pipeline checks: Continuous integration (CI) pipelines automatically run tests, builds, and static checks on every commit. PStack's related skills can read CI failure logs, locate problems, and attempt fixes, shortening the feedback loop.

Auxiliary Skills and Principle Skills: The Token Economics of On-Demand Loading

In addition to the six-stage main flow, PStack also has a set of auxiliary skills that can be invoked at any time. The routing skill Petito Mode helps you clarify your problem and select the appropriate skill to handle it when you don't know which skill to call.

There are also skills for installation and setup, recalling context, writing, and continuously improving PStack itself. The Bilibili creator especially likes the group used to fill in context and explain things simply, particularly Recall—when you're switching back and forth between several projects and want to recall where a particular project left off, this group of skills helps you catch up.

PStack also contains a large number of principle skills. Why write them as skills instead of putting them directly into the system prompt? The reason is token cost: cramming all the rules into the system prompt turns it into a huge file that the AI must read on every message, and the information may not be relevant to the task at hand. PStack breaks these principles into several skills and pairs them with an index chart that specifies when each principle should be triggered.

The Bilibili creator picked out several of the most helpful principles. The first is keep it simple and control scope, similar in spirit to the Ponytail skill. The second is a principle about "stuck loops": sometimes you ask the AI to fix a problem, it says it's fixed but the problem persists, you fix it again and it still happens—the AI gets caught in a loop of fixing while being stuck. This skill requires the AI to stop first and re-examine its assumptions—before continuing to act in the same direction, confirm whether the chosen path is right. The third is type system discipline: impossible states must be ruled out, for example, a payment cannot simultaneously be both paid and pending payment; this should be solved through type design.

Token economics: Large language models are billed by token, and context windows are limited. Putting a large number of principle rules into the system prompt causes every request to carry a lengthy prefix, which both increases cost and may dilute attention to key instructions. PStack splits principles into independent skills that are loaded only when triggered, implementing an "pay-as-you-go" context management strategy.

Type system discipline: Leveraging static type systems such as TypeScript, through union types, literal types, and immutable state modeling, illegal states become unrepresentable at compile time. For example, use type Payment = { status: 'paid' } | { status: 'pending' } instead of boolean flags that can be true simultaneously, eliminating a class of runtime errors at the root.

Framework Selection from Multiple Perspectives

Combining the Bilibili creator's breakdown with Lauren Tan's publicly available repository design, PStack's differentiated value lies in two points: first, its pragmatic positioning for existing projects; second, its multi-model collaborative design and review mechanism. But its boundaries should also be recognized—planning from scratch is not its strength, and the maintenance loop also needs to work with other frameworks. For teams building AI coding workflows, PStack is more like a referenceable "skill organization methodology" than a one-stop solution.

The Bilibili creator says they will put the PStack skill map and comparison page links in the video description so developers can study them directly. Whether or not you ultimately adopt this framework, its design ideas around comment noise, multi-model racing, and on-demand loading of principles are all worth incorporating into your own AI coding practice.

One-line Summary

React core team member open-sources PStack, a six-stage AI coding skills library for existing projects.

Paragraph Summary

PStack is an open-source AI coding skills library by Lauren Tan, focused on continuous development of existing (Brownfield) projects. It divides the AI software development lifecycle into six stages: planning, design, build, test, deploy, and maintain. The design stage uses a "racing" mechanism where multiple models each produce plans that are then compared and integrated. The build stage emphasizes TDD and TypeScript best practices, and cleans up AI-style code through the Deslop skill. The test stage includes end-to-end verification, multi-agent division of labor (Swarm), and Interrogate review that actively attacks changes. Principle skills use on-demand loading instead of being crammed into the system prompt to save tokens. PStack's differentiated value lies in its pragmatic positioning and multi-model collaboration, but the maintenance loop needs to work with other frameworks.