The Methodology That Outgrew Its IDE

The most interesting artifacts in the AI tooling world right now are not code. They are folders of markdown files — skill libraries with star counts that embarrass established frameworks, telling coding agents how to behave. Somewhere in that pile sits a smaller, stranger artifact: a port. pstack-claude takes Lauren Tan’s pstack, an opinionated workflow stack built for Cursor, and rehouses it for Claude Code, Codex, and other agent harnesses. It is not the official package. It is, by its own README’s description, a “faithful port” — and the fact that a port is needed at all tells you something about where the value actually lives in this ecosystem.

What pstack is, and why anyone cares

pstack is the work of Lauren Tan, known online as @poteto, an engineer at Cursor. As Flavio Copes documents in his deep dive, it is considerably more than a prompt collection: 24 workflow skills, 23 engineering principles, 22 task playbooks, 2 specialized subagents, helper programs, and an optional automation pack. The stated goal is not more code. It is less code, higher quality, and enough verification that several agents can work in parallel without turning the repository into a mess.

The origin story matters here. Before joining Cursor, Tan used Claude Code and built her own orchestration layer around it. The lesson she took from that period was not “run more agents” — it was that agents behave like new engineers who keep forgetting everything the team taught them. Rules, skills, tools, and memory are how you fix that. pstack turns repeated agent failures into explicit playbooks, with the explicit strategy of making one agent trustworthy on a complete problem before multiplying it across many tasks. At launch, Tan showed her skills had been used 9,000 times inside Cursor in a single week. pstack is those internal habits, packaged publicly.

The user-facing shape of the thing is deceptively simple. You invoke poteto-mode, describe a result you want, and it acts as a router: it reads a principles index, matches your request to a playbook — bug, feature, refactor, investigation, performance — then calls specialist skills, delegates work by model role, and demands evidence before reporting success. A bug report gets reproduced, investigated with the how and why skills, fixed, and rerun against the failing case. You receive the fix plus the failing and passing evidence. That last clause is the whole philosophy in miniature: an agent that has to show you the test going red and then green is an agent you can trust in parallel.

Why a port exists

Here is the boring part, which is also the interesting part. pstack ships as a Cursor plugin. But the skills themselves are SKILL.md files — the same format Claude Code, Codex, and other agents already load. The instructions are portable; the packaging is not. Copes notes you could copy the skill folders into another tool’s skills directory yourself, and he even built a tool to check which agents load which skill. pstack-claude is the version of that work someone did for you: it translates the Cursor-specific pieces to Claude Code equivalents, ships a Codex plugin alongside, and installs a routing hook so poteto-mode can intercept requests the way it does in Cursor. On Codex, the harness asks you to trust the hook before it runs — a small, honest friction point that says something about how differently the two tools treat injected automation.

The port also handles the plumbing differences: model defaults are configurable, automatic routing can be turned off, and there are skills-only install paths for Prime Agent, OpenCode, and Gemini CLI. None of this is glamorous. It is translation work — the kind of glue engineering that usually goes unthanked and occasionally turns out to be what an ecosystem actually runs on.

What survives the crossing

The port’s central claim, and Copes confirms it, is that the substance of pstack is instructions, not Cursor APIs. The playbooks, the engineering principles, and the interrogation skills — how, why, interrogate — all make sense outside Cursor because they were never about Cursor. They were about how a competent engineer approaches a bug: reproduce it, understand it, fix it narrowly, prove it fixed. That is exactly the kind of knowledge that ports cleanly between harnesses, because it was never harness knowledge to begin with.

This maps neatly onto what the broader skills community has learned about what makes a skill work. The Firecrawl roundup of the best Claude Code skills identifies the pattern: good skills have descriptions that read like routing rules, lean instruction bodies, and one job each. pstack’s architecture — a router skill that pulls in specialist skills on demand, with playbooks copied verbatim into a task list rather than paraphrased — is a more disciplined version of the same idea. Copes highlights a telling detail: the model does not read a playbook and then improvise a shorter plan. It gets the playbook verbatim, because an agent left to summarize its own instructions will quietly drop the steps it finds inconvenient.

What doesn’t survive

Now the honest accounting, because a port is defined by its losses. Per Copes, the Cursor-only pieces you give up are: the /add-plugin flow, the setup skill that writes Cursor’s model-configuration rule file, the /loop command, and — most consequentially — the ability to assign a different model to each subagent.

That last one is not a minor feature gap. It may be the core of the original design. Tan has been explicit on X about why pstack uses multi-model workflows: her framing is that an agent harness given complete freedom becomes an ouroboros, a serpent eating its own tail, and that a strong model like Opus works best as a manager orchestrating other models rather than doing everything itself. pstack’s bundled defaults split work by model strength — implementation to one model, judgment and prose to another, review panels mixing several. Cursor can assign those models per task. Claude Code, in the port’s current form, largely cannot replicate that per-subagent model assignment. Copes’s verdict is blunt: Cursor remains the best fit, precisely because pstack wants different models for different jobs.

So the port delivers pstack’s discipline without pstack’s full orchestration. Whether that matters depends on what you think pstack is. If it is primarily a methodology — reproduce, investigate, verify, ship with evidence — the port is nearly whole. If it is primarily a multi-model management system, the port is a good simulation running on a weaker engine. The truth is probably that the methodology is the part most people need, and the multi-model layer is the part that made the original feel magical.

The ecosystem moment

pstack-claude is not happening in a vacuum. It is riding two converging waves.

The first is the skills explosion. Since Anthropic launched the Agent Skills format in October 2025, the category has become one of the most-starred new genres of developer tooling — Superpowers sits around 226,000 stars, a Karpathy-derived rules file has 174,000, and neither is code in any meaningful sense. The format’s power is progressive disclosure: an agent preloads only each skill’s name and description, pulls the body in when a task matches, and loads reference files only if needed. You can have fifty skills installed and a clean context window. That mechanism is what makes a 24-skill stack like pstack feasible at all — in a world of giant system prompts, it would have drowned.

The second wave is standardization. Agent Plugins 1.0.0 is a vendor-neutral spec for packaging skills and MCP servers into portable plugins, published by maintainers from Amazon, Cursor, Microsoft, OpenAI, and Vercel, with Google joining the group. Its design philosophy is directly relevant to pstack-claude’s existence: a fixed directory layout for the portable parts, and a per-client extension namespace for the non-portable parts, so that “the non-portable parts have somewhere legitimate to go.” The spec’s authors describe the exact problem pstack-claude solves by hand — the wrapper around the components being different in every client, forcing authors to fork packages and watch them drift. pstack-claude is, in effect, a manual fork of pstack’s wrapper with the drift managed by one maintainer’s discipline. If the plugin spec lands broadly, ports like this become less necessary — or become the thing the spec’s escape-hatch directories formalize.

The limits, stated plainly

It is worth being clear about what this repository is. It is a port, maintained by a third party, tracking an upstream that lives inside Cursor’s plugin repository and evolves on Cursor’s schedule. The README is upfront about scope and points to a maintenance page for what the port covers; the license situation is handled carefully, with the original credited to Tan and imported Cursor team-kit skills carrying their own notices. But upstream changes will arrive here at the speed of one maintainer’s attention, and the multi-model orchestration that defines the original will remain structurally out of reach until Claude Code and Codex grow per-subagent model assignment — if they ever do.

There is also the general skills-ecosystem noise to contend with. The same sources that celebrate skills warn about trap skills: bloated instruction files, vague triggers, bundled scripts that do things the description never mentioned. pstack’s architecture — routing descriptions, verbatim playbooks, evidence requirements — is on the right side of that divide, but anyone installing a 24-skill stack with an automation hook should understand they are installing a lot of behavioral surface area at once. The port’s own answer is the setup skill that lets you change model defaults or disable automatic routing entirely, which is the right kind of escape hatch.

Outlook

The interesting question is not whether pstack-claude is a good port — it appears to be a careful one — but what it portends. The skills category is converging on a small number of heavyweight workflow systems (Superpowers, the Karpathy rules, pstack) that each encode a philosophy about how agents should behave, and a long tail of single-purpose skills. pstack’s philosophy — go deep before going broad, verify before declaring victory, treat agents like forgetful new hires — is among the most coherent of the bunch, and it is now available outside the IDE it was born in.

Meanwhile, the platform gap that makes the port second-best may close. Claude Code has been absorbing orchestration features at speed — plugins, marketplaces, parallel sessions, routines — and the Agent Plugins spec is busy making the box portable so nobody has to hand-port the wrapper again. When the platforms converge, the differentiator will be what was always the differentiator: the playbooks. Lauren Tan wrote those for agents that keep forgetting how good engineers work. That knowledge, it turns out, fits in a folder of markdown files and crosses IDE boundaries without losing anything but the magic.