Pace for GitHub Copilot

Install

From the root of the repo you want Copilot to work in:

curl -fsSL https://raw.githubusercontent.com/GoldenBerry-SO/Pace/main/copilot/install.sh | sh

On Windows, or if you prefer npm:

npx pace-tools copilot

Both add files and never delete yours. A skill, prompt or agent that already exists is kept unless you pass --force. --dry-run shows what would change and writes nothing. Then commit .github/, so the whole team and the coding agent get the same setup.

What lands where

.github/
├── copilot-instructions.md      # read on every request: the house rules, short
├── skills/
│   ├── grill-me/SKILL.md        # read when a task matches: the full instructions
│   ├── to-prd/SKILL.md
│   ├── to-issues/SKILL.md
│   ├── tdd/SKILL.md
│   └── … 29 more, with their reference files
├── prompts/
│   ├── grill-me.prompt.md       # /grill-me in Copilot chat; reads the skill
│   └── … one per skill
└── agents/
    └── reviewer.agent.md        # @reviewer: a fresh reading of a pull request

Two kinds of file. The instructions file is loaded into every session, so it holds only the rules that apply to everything and stays under a screen. The skills folder holds the long instructions; a task reads only the one it needs, and the prompt files are the slash commands that point at them.

The instructions file

Pace adds a block to .github/copilot-instructions.md between <!-- pace:start --> and <!-- pace:end --> markers. If the file already exists, the block is appended after your own text; a later install refreshes only the block. What it says, in short:

• When a task matches a skill in .github/skills/, read that file first and follow it.
• Work one issue at a time, as a thin slice through every layer it touches.
• Test first: a failing test, the smallest change that passes, then tidy. Never edit a test to make it pass.
• Run every check the repo has before saying it is done, and paste the result.
• Ask in chat when unsure. Never force-push, bypass hooks, or delete without being asked.

Path-scoped rules go in .github/instructions/*.instructions.md with an applyTo pattern; Pace leaves that folder to you. The CLI also reads AGENTS.md and CLAUDE.md when they exist and applies no precedence between them, so keep the pace block and those files from contradicting each other.

The commands

In VS Code, type / in Copilot chat, in agent mode, to see them; the prompt files make each skill a slash command there. In the Copilot CLI, prompt files are not read, but a skill can be called by name the same way: /grill-me in your prompt loads the skill, and /skills list shows what is installed. The five that make up a feature from idea to shipped:

/grill-me <a brief>     # one question at a time, with a recommended answer, until you agree on what to build
/to-prd                  # writes the destination down: problem, stories, decisions, out of scope, modules to touch
/to-issues               # slices it into issues that each cut through every layer, marks which can run unattended
/tdd                     # red, green, refactor on one issue
/code-review             # a second reading of the change

Run /setup-engineering-skills once per repo first: it tells the skills where your issues live, which labels you use and where your docs are. The rest of the catalog covers debugging (/diagnose), incidents, documentation, deploy checklists, stacked pull requests (/spec, /implement, /topr), triage and architecture (/improve-codebase-architecture). Every skill is listed in the skill catalog.

One engineering skill is left out: git-guardrails-claude-code installs Claude Code hooks and has no Copilot equivalent.

The coding agent and the reviewer

Assign an issue to Copilot and the coding agent works it in a GitHub Actions runner and opens a pull request. It reads the same copilot-instructions.md and the same skills, so it tests first and runs the checks like anyone else on the team.

@reviewer is a custom agent in .github/agents/. It reads a diff in a fresh context, with the standards in front of it, and returns findings marked P1, P2 or P3 and a verdict: approve, or send back. Use it on the coding agent's pull requests before a person reads them.

From the terminal

The Copilot CLI reads the same files: copilot-instructions.md on every prompt, the skills when a task matches or when you name one, the agents through /agent or a flag. Two commands worth knowing:

# one issue, unattended: the loop from the talk, on the CLI
copilot --autopilot --yolo --max-autopilot-continues 10 -p "Take issue #14 with the /tdd skill and stop when the checks pass"

# the reviewer, on a diff, in a fresh session
copilot --agent=reviewer -p "Review the diff on this branch against main"

--yolo approves every tool without asking, so run that form in a container or a throwaway checkout. Inside a session, /delegate hands the task to the cloud coding agent instead, which commits to a new branch and opens a draft pull request.

Updating

Run the install again. New skills are added, the pace block in the instructions file is refreshed, and anything you changed is kept unless you pass --force:

npx pace-tools copilot           # adds what is new, keeps what you edited
npx pace-tools copilot --force   # replaces the skills, prompts and agent with the current versions

To install from a branch or tag instead of main, set PACE_REF in front of either command.

Verifying it worked

Open the repo in VS Code, open Copilot chat in agent mode and type /grill-me. It should appear in the list and, when run with a brief, start asking questions one at a time. In the CLI, start copilot in the repo and run /skills list; the Pace skills should be there. If you installed while a session was open, run /skills reload, and restart the session for the instructions file, which the CLI reads at start. Copilot's file layout moves between releases, so check the paths above against the current Copilot docs if a command does not show up.

Stuck? Open an issue at github.com/GoldenBerry-SO/Pace.