Slop Is a Choice: The React Veteran Teaching Agents to Slow Down

The most-starred new category in developer tooling isn’t a framework, a runtime, or even code. It’s folders of markdown — “agent skills” — that tell your coding agent how to behave. One roundup notes that Superpowers, a full spec-driven methodology in skill form, sits around 226,000 stars, ahead of Vue; a community-built file of Andrej Karpathy’s failure-mode advice (which Karpathy didn’t write) has 174,000. Into this crowded, slightly unhinged market walks pstack — and it arrives with something most of its competitors lack: an author whose day job is exactly the problem the skills claim to solve.

The person behind the folder

pstack is the personal skill stack of Lauren Tan, known online as poteto. The README is blunt about the résumé: millions of lines of code at Meta, Netflix, and Cursor, plus a seat on the React core team working on React Compiler. This matters more than it usually would. The agent-skills gold rush has produced a lot of advice from people whose engineering credentials are hard to verify; pstack’s pitch is that these are literally the skills Tan uses every day to ship at Cursor, and in a long-form guide on X, the claim gets more specific — pstack enabled shipping 2,000 PRs a month to production, and acting as the self-described “gardener” of the Grok Bot codebase while hundreds of PRs a day land from a growing team.

The framing is unusual for this genre. Most skill collections sell speed. pstack’s thesis is closer to the opposite: “if you want to go fast, go deep first.” The goal, the README says, is not to maximize lines of code — “in fact it’s the opposite.” Whether that’s marketing or conviction, the design of the thing backs it up.

The router is the product

Strip away the personality and pstack is an architecture, and the architecture is more interesting than the sum of its slash commands. The entry point is a single skill, poteto-mode, which is a router: it reads your request, matches it against twenty-three playbooks — bug fix, perf, hillclimb, runtime forensics, visual parity, overnight autonomous run, babysit a PR through CI — and then dispatches to the other fifty-odd skills as each step needs them. It’s sticky: once invoked, it stays on across turns, applying itself when a playbook matches and staying out of the way otherwise.

This is the boring part, and the boring part is where the value is. A pile of fifty skills is unusable — the agent has to know which to load, and so do you. A router with playbooks turns a catalog into a system. It’s the same insight behind every ops platform ever built: the individual tools matter less than the dispatch layer that decides which tool fires when.

Underneath sit twenty-four “principles,” each a tiny skill stating one rule: bias toward deletion and the smallest change; make illegal states unrepresentable; verify against the real artifact, not a proxy or “it compiles”; if a test would still pass when every imported function returns undefined, delete the test. The principles are indexed inline inside poteto-mode and read at task start, so the agent internalizes the rulebook before touching anything. Other skills can reference a principle by name, which is a genuinely elegant touch — it’s a citation system for engineering judgment.

The multi-model routing is the other structural idea. Frontier models have different strengths, and pstack exploits that by default: code delegates go to Grok, while the hardest changes, prose, and judgment go to Opus, with a configurable panel behind a setup skill. Review is adversarial by design — /interrogate throws a diff at several different models and asks each to break it, including one lens that is strictly about code quality.

And then there’s Comment Sicko, a read-only subagent the Cursor marketplace describes as “a deranged comment-hater that savors deletion and condemns workaround code.” It strips comments before review so the code has to stand on its own, then fixes whatever the review accepts. The naming is a bit much, but the idea is sound: comments are where unverified claims about code go to hide.

Verification as infrastructure

In the guide post, Tan calls the verification skill “critical infrastructure rather than ‘just’ a skill” — the thing that lets an agent close its own loop, keep going until it succeeds, and stop treating the human as the bottleneck. The claim attached to this is large: done well, it will “100-1000x your whole team’s output,” including non-engineers. That number is an assertion, not a benchmark — but the mechanism behind it is real and worth taking seriously.

The argument goes like this: an agent that can prove its own work — run the feature, read the actual value, drive the app through Chrome DevTools Protocol or an iOS simulator — doesn’t need you to check its homework. pstack’s create-verification-skill is a meta-skill that generates a project-local verification skill with a feature map for whatever stack you’re on, and a companion skill keeps that map from drifting as the app changes. Tan’s position is aggressive enough to include stack choice: if your platform lacks a rich runtime to verify against, build the tooling, or pick a different stack. That’s a strong claim — verification as a first-class criterion for choosing technology — and it’s the most intellectually distinctive thing in the whole collection.

It also explains the overnight-run playbooks. “I’m going to bed, land the stack even if CI flakes, I want everything merged by morning” only stops being a nightmare if the agent can independently verify a green stack before landing it. Parallelism without verification is just slop at scale; parallelism with it is what the README calls “fearless.”

The mirror, the ports, and the ecosystem

The repo under review here, backnotprop/pstack, is itself a signal. It’s a standalone mirror of the upstream plugin inside Cursor’s official plugins repo, kept in sync so the skills work in Claude Code, Codex, Pi, and other harnesses — with the mirror’s stated change being that many Cursor-specific skills were rewritten to be harness-agnostic. The upstream commit history shows active, fast iteration: version bumps to 0.15.x within days of each other, fixes for a subagent that couldn’t find its own mode file, frontmatter keys Cursor was silently ignoring.

It doesn’t stop there. A separate community port, michael-denyer/pstack-claude, has 253 commits, tracks upstream, declares its policy forks in a JSON file, and carries a companion plugin adding TLA+ model checking and Lean proofs for concurrency invariants that tests can’t reach. When people are porting your markdown across four harnesses and bolting formal methods onto it, you’ve crossed from project to platform. The Agent Skills format — a directory with a SKILL.md, born at Anthropic — is what makes this possible: skills are just text, so text travels.

Where it sits in the field

The landscape is sorting into philosophies. Superpowers owns the whole loop: spec first, sign-off, then subagents building and reviewing each other’s work — heavy process, heavy tokens. The Karpathy file is the opposite: four behavioral rules, no ceremony. Addy Osmani’s agent-skills takes a middle path with a lifecycle of eight commands, anti-rationalization tables that pre-rebut the excuses agents make to skip steps, and — notably — an in-repo eval framework that holds the catalog to its own standard.

pstack is distinct on two axes. First, it’s anti-planning by conviction: “i don’t believe in planning. the best spec is code.” Where Superpowers front-loads a spec, pstack front-loads verification and lets the code be the spec. Second, it’s personal rather than procedural — poteto-mode is explicitly one engineer’s style, and the collection ships /automate-me, which mines your own transcripts and drafts a you-mode skill on top of pstack as a base. That’s an honest answer to the obvious objection: you may not want Tan’s judgment, and the project doesn’t insist you should.

The limits, honestly stated

What pstack doesn’t have, at least in anything visible here, is Osmani-style evals. The skills are measured by one person’s production experience, which is a real signal but not a reproducible one. The “100-1000x” and “2,000 PRs a month” figures are self-reported and unfalsifiable from the outside. The token appetite is also real: multi-model review panels, parallel arena attempts, and a mode skill that reads its full principles index at task start are not cheap, and the same roundup that praises skill collections warns that the heavyweight ones eat tokens fast.

There’s a deeper tension worth naming. Anthropic’s randomized controlled trial on AI assistance and skill formation found that developers using AI scored 17% lower on mastery of concepts they’d just used — unless they used AI to build comprehension while working. pstack is, in effect, a bet that the second pattern can be engineered: it ships /teach, /how, and /why skills whose entire job is explanation, not output. Whether a routing system that also automates overnight merges actually cultivates the human’s understanding, or just automates around its absence, is an open question the repo can’t answer by itself.

The rough edges are visible and mostly mundane: the mirror admits the skills needed rewriting to escape Cursor; the port documents a Copilot CLI bug where cached experiment assignments make skills unfindable in non-interactive sessions; a commit exists purely to shrink a logo under a size limit. These are the scars of software that ships.

Outlook

The open questions are the interesting ones. Will the mirror and the ports stay in sync with an upstream that iterates daily, or will harness-specific forks diverge into incompatible dialects? Will the personality-driven model — one gardener’s judgment, encoded — scale to teams that never met poteto, or does /automate-me become the real product? And can a markdown folder hold the line against model improvement, as frontier models internalize the discipline the skills currently impose from outside?

For now, pstack’s contribution is a stance, argued in structure rather than prose: slop is not an inevitability of AI coding, it’s a default the agent falls into when nobody encodes the alternative. The alternative, it turns out, fits in a folder — router, playbooks, principles, and a deranged comment-hater to keep the code honest.