A walkthrough of P-Stack, an open-source repo of AI coding skills, workflows, and principles published by Lauren Tan (Cursor, ex-Meta/React team). The reviewer maps her skills onto a six-stage AI software development lifecycle — planning, design, building, testing, deployment, maintaining — and notes the defining difference from other skill sets he's reviewed: P-Stack fans work out across multiple models and agents instead of relying on a single model. He concludes that the planning skills are weak for greenfield solo building, but the design fan-out, the 'no comments' rule, 'attack the premise,' and the type-system principles are worth stealing.
- P-Stack is built mostly for brownfield work — existing codebases, migrations, large changes — with 'how', 'why', and 'teach' skills for learning code and 'figure out' plus 'show me your work' for splitting tasks into tickets and logging decisions to markdown.
- The design stage is the biggest departure from other skill sets: an 'architect' skill triggers an 'arena' where multiple models (Opus, GPT, Grok) fan out to propose designs, then 'interrogate' judges and aggregates the best parts into a single design report.
- The building stage pairs a TDD skill with a TypeScript best-practice skill and a 'cleanup diff' skill that diffs the feature branch against main and strips AI slop — stray comments, over-broad try/catch, untyped variables, deep nesting — while keeping behavior identical by re-running tests.
- The 'no comments' rule exists because AI agents often read a stale comment instead of the actual code; if a comment says the function returns A but the code returns B, the model may trust the comment, so removing comments removes that noise.
- Testing separates unit-level TDD from a 'create verification' skill that builds the whole end-to-end harness — spinning up databases and servers, driving user behavior, collecting evidence, tearing things down — with one feature per folder, then uses a 'swarm' of agents on small parts and 'interrogate' plus a 'thermonuclear code quality review' to attack the diff.
- Deployment covers PR hygiene end to end: making PRs easy to review, babysitting the merge, fixing merge conflicts, pulling review comments, and fixing CI; there are no maintenance-stage skills in P-Stack.
- Principles are kept as separate skills with an index map rather than stuffed into a system prompt, because a giant always-loaded prompt burns tokens on rules irrelevant to the current task.
- Two principles the reviewer plans to adopt: 'attack the premise' — when an AI loops on fixing a bug that keeps recurring, stop and question the assumption rather than keep patching — and type-system discipline that rejects impossible states, e.g. a payment that is both paid and pending.
This is the structural difference between P-Stack and every other skill set reviewed on the channel — design by committee of models, then judged and merged.
The architect here is going to trigger the arena to basically have multiple different models and multiple different AI agents fan out and do the design... once we have multiple different designs, we trigger a skill called interrogate, which will have an AI model judge the results and aggregate them back into a single report.
A concrete, counterintuitive rationale for a rule most developers would reflexively disagree with.
Let's say we have a comment says that this function returns A, but this function in the code, it returns B. So what does AI listen to? Well, the AI sometimes just looks at the comments rather than the code.
Often time AI sometimes just reads the comments instead of the code.
It's going to continuously cycle through a loop where we have AI fixing and then blocked, fixing and then blocked... what this skill does is stop and have AI question the assumption.
A payment here could not be paid and also pending at the same time.