Skip to content
  1. How-to
  2. Prompts
  3. Copy-paste prompts

Copy-paste prompts

In one lineFind a prompt for the situation you're in, swap out the angle-bracket parts, and send it.

Look things up as you goFor: You want a prompt you can copy, tweak, and sendFull guide step 3: Your first task

Replace the angle-bracket parts with your own: paths, commands, what “done” means. Keep skill names as they are, since those are the names the AI knows.

Understand it first

Ask how it works, then why it broke

Copy this
Use /pstack:how to figure out how this initialization works, then /pstack:why to find out why it broke recently.

Each report names the sources it checked.

A long discussion? Have it restate the problem

Copy this
/pstack:poteto-mode read this thread. In your own words, in plain language, restate the root problem. Don't change any code yet.

If it misread you, the restatement shows it. Share your own guess after it’s done.

Sharpen the prompt before you send it

Copy this
/pstack:sharpen write an onboarding doc for the new billing service.

It adds what you left out and hands back a rewritten prompt. It doesn’t do the work.

Pick up where you left off days ago

Copy this
/pstack:recall what I did on <topic> last week, then read <issue link>.

A new conversation doesn’t remember old ones. Have it read your records first.

Make it convince you

Copy this
/pstack:teach me why you built it this way instead of <another approach>. What did you trade off?

Holes are easier to spot in an argument than in a summary.

Fix bugs, add features, refactor, chase slowness

Fix a bug

Copy this
/pstack:poteto-mode <symptom>. Reproduce it first, then fix it, then verify.

“Reproduce” means make the problem happen again. For the full version, see Fix a bug.

With a verification skill, ask for a video as proof

Copy this
/pstack:poteto-mode use /verify-<your-app> to reproduce this. If it reproduces on main, fix it and give me a video as proof.

If the problem is already gone, it stops early. A video lets you check without reading code.

When a test is easy to write, write it first

Copy this
/pstack:poteto-mode reproduce the duplicate write first. If there's a cheap test path, /pstack:tdd it: write a failing test, then fix, then run it again.

When a test is hard to write, running the real command is more convincing.

Add a feature without breaking the old one

Copy this
/pstack:poteto-mode add <new behavior>. <current output> must stay byte-for-byte identical. Verify both.

“Byte-for-byte identical” can pass or fail. “Don’t affect the old feature” can’t.

Refactor with no change in behavior

Copy this
/pstack:poteto-mode move <this code> into one module with zero behavior change. Record the current output before you start, and prove it hasn't changed when you're done.

Record the “before” first, so there’s something to compare against.

Chase slowness with numbers

Copy this
/pstack:poteto-mode <some operation> takes <how long> on <some test data>. Capture a performance trace, fix the cause it shows, and show me before and after numbers.

“Faster” only means something with a starting number.

Settle a design, make a plan

Build a few prototypes, then pick

Copy this
/pstack:poteto-mode build a few prototypes of the settings page layout. Put them behind a toggle and send me a screenshot of each.

Picking from things that run beats picking from descriptions.

A bigger design, with a review point

Copy this
/pstack:poteto-mode we need to add rate limiting to external webhooks. /pstack:architect first, and answer anything uncertain with prototypes. Let me review before you continue.

The last sentence makes it stop and wait for you before writing real code.

A package others will use: write the tutorial first

Copy this
/pstack:poteto-mode first write a tutorial showing how I'd use this new config package. Then /pstack:teach me why it's better than what we have now.

Writing the tutorial first makes it think like the people using it.

Get a second opinion

Copy this
Have /pstack:arena give a second opinion on this discussion and our plan.

It tells you whether other models found something better, or agree with yours.

Once the design is settled, ask for the plan

Copy this
/pstack:poteto-mode turn this design into a plan. Break it into small, verifiable PRs, each with its own verification steps.

It hands over only the plan. It won’t start writing code.

Migration plan: keep the bugs too

Copy this
/pstack:poteto-mode plan the migration from <some library> to <new approach>. Break it into small, verifiable PRs. The results must match the old ones exactly, bugs included.

Fixing bugs mid-migration makes old and new results impossible to compare.

Check before shipping

Pick it apart before you commit

Copy this
/pstack:interrogate the whole branch, and be picky. Don't change anything yet. Don't report nitpicks unless it's a real bug or a regression.

Glance at the items it dropped in the report, too.

Check many things at once

Copy this
/pstack:swarm run each package's check.sh under packages/. One worker per package, then give me one report.

You read one summary.

Cases tests can’t reach

Copy this
/pstack:create-formal-verification-skill for the retry queue. A message must never be delivered twice.

It checks this one rule in every case, and can recheck it on every later change. See formal verification.

Check a number before you publish it

Copy this
/pstack:benchmark-checklist check this 40% speedup before it goes in the PR description.

The verdict is only ever faster, slower, no difference, or can’t tell.

Stop correcting the same mistake by hand

Copy this
/pstack:correct the AI keeps adding new config options without registering them in the schema.

It changes the repo itself, so the next AI can’t make the mistake.

Open a PR and watch it until it can merge

Copy this
/pstack:poteto-mode open a PR. Small commits, in order, with evidence in the description.
Copy this
/pstack:poteto-mode watch this PR and get it green.

It won’t merge unless you say so.

Leave and come back

Before bed

Copy this
/pstack:poteto-mode I'm going to bed. In a new worktree (branched from <base branch>), <goal>.
Done means: <a check that passes or fails>.
Keep a decision log. No need to ask me before committing.
/loop until done. If you're truly stuck after a few hours, stop and write down why.

“Done means” gives every round something to check. See Let it run.

Come back and see what it did

Copy this
/pstack:show-me-your-work walk me through what you did last night.

Read the “needs attention” part first. Every line in the decision log has a reason and evidence.

Just want to know what changed in this conversation

Copy this
/pstack:ketchup

It lists what changed and what’s waiting on your decision. It only looks, never changes.

Just want to ask how

Copy this
/pstack:poteto-help how do I keep poteto-mode on for every turn?

You get an answer and a prompt. Nothing runs unless you send it.

Can’t follow the reply

Copy this
/pstack:bro

It says the last reply again in plain words.

Write down what you learned

Copy this
/pstack:reflect this was too slow. Write down what we learned so it doesn't happen again.

It only suggests changes. Nothing changes until you approve.

For one-line ways to pull it back when it drifts, see Pull it back on track.

Common mistakes

  • Ordering skills in the prompt. State the goal and requirements. It orders the skills itself.
  • A vague definition of done. “Make it better” can’t be checked. Give a command or result that passes or fails.
  • Leading with your guess about the cause. It will only look where you pointed.
  • Going with the first design. Ask for prototypes first, or use /pstack:architect.
  • Several AIs crammed into one folder. They overwrite each other. Give each attempt its own worktree.
  • Starting a loop before you trust it. Get your verification skill working first, or you just get unchecked work faster.
  • Believing a number you haven’t checked. Run /pstack:benchmark-checklist first.
  • Using /pstack:arena like /pstack:swarm. /pstack:arena does one task several times. /pstack:swarm splits work into different pieces.
  • Accepting every review comment. Use /pstack:interrogate. It keeps only the problems it can prove.
  • Treating auto as a model name. It means “follow the main conversation.” See Keep costs down.
  • Calling a passing build a success. Compiling only proves it compiles. Ask for real command output.
  • Writing SKILL.md by hand. Have /pstack:poteto-mode write it. It brings checks along.

Stuck?

I copied it exactly, but it did something different from what I wanted.

Most likely, what “done” means wasn’t clear. Add one check that passes or fails, like “this command returns 0.” Still unsure? Run the prompt through /pstack:sharpen before you send it.

Can I write prompts in a language other than English?

Yes. Just keep skill names (/pstack:how) and principle names (prove it works) in English.

I don't know which one to copy for this task.

Ask /pstack:poteto-help. It gives you a ready-made prompt. You can also read Not sure which skill to use.

An unofficial beginner's guide to pstack, not its official docs. pstack is made by poteto; the official repo is the source of truth for commands and behavior. The original guide source is on GitHub.

Hosted by airali. Adapted from Xiaoxiaodong's MIT-licensed guide.