GitHub Copilot

Verified against GitHub Copilot Workspace · 2026-07-24

Force Copilot Workspace through spec, plan, and pilot before it writes real code

A Copilot Workspace brief that keeps the tool's three built-in stages — specification, plan, and implementation — from collapsing into one pass, requiring a reviewable spec and a dependency-ordered plan, plus a one-file pilot for anything touching more than a couple of files.

GitHub Copilot Workspace6 fillable variables

The prompt

Ready to copy — highlighted parts are example details you can swap.

Open this issue in GitHub Copilot Workspace. Workspace has three distinct stages —
specification, plan, and implementation — and each one is individually editable before you
advance to the next; do not let it collapse straight to a diff. Stop at the end of each stage
below and wait for explicit approval before Workspace proceeds to the next one.

ISSUE
Users on the free tier can currently export more than 3 reports per month by editing the request payload directly.

ACCEPTANCE CRITERIA
1. Free-tier requests past the 3rd export in a rolling 30 days return a 403 with a clear error message. 2. Paid tiers are unaffected. 3. The limit is configurable, not hardcoded.

CONSTRAINTS
Must use the existing rate-limit middleware in lib/middleware/rate-limit.ts, not a new library.

OUT OF SCOPE
Billing-plan changes, upgrade prompts in the UI, and retroactive enforcement on exports already made this month.

SPECIFICATION STAGE
When Workspace proposes the spec, check that it restates the problem in its own words rather than
echoing the issue text back verbatim, names every file it currently believes it will touch, and
flags — rather than silently resolves — any place the acceptance criteria above are genuinely
ambiguous. If the spec resolves an ambiguity without flagging it, reject it and ask specifically
which interpretation it chose and why, before moving on.

PLAN STAGE
Once the spec is approved, check the plan against these two things before approving it in turn:
first, that its steps map one-to-one onto the numbered acceptance criteria, so nothing in the plan
exists that the acceptance criteria did not ask for and nothing the acceptance criteria did ask
for is missing a corresponding step; second, given the rough scope of Roughly 4 files: the middleware, a new config constant, the export route handler, and one new test file., that
foundational files — shared types, config, anything another file in the plan depends on — are
scheduled before the files that depend on them, not in whatever order Workspace happened to list
them.

CHECKING CONSTRAINTS SPECIFICALLY
Before approving the plan, go back through every item in Must use the existing rate-limit middleware in lib/middleware/rate-limit.ts, not a new library. individually and confirm
the plan actually satisfies it rather than simply not contradicting it outright — a constraint
that says an existing helper must be reused is violated just as much by a plan that quietly writes
a new parallel helper next to it as by one that removes the existing helper entirely, and only the
second version is likely to be caught by skimming.

IMPLEMENTATION STAGE
Implement lib/middleware/rate-limit.ts's export-count check first as the pilot — it is the foundational piece everything else calls into.
If this issue touches more than two or three files, ask Workspace to implement only the single
file named above first and stop, so a wrong approach costs one file's diff to revert rather than
the full change. Once that file's diff looks right against the approved plan, allow the rest to
proceed.

THROUGHOUT ALL THREE STAGES
Do not let Workspace treat a stage as a formality to click through quickly on its way to the code
— an unread spec approved out of habit gives you nothing more than skipping it entirely would,
except the appearance of having reviewed it. If any stage's output does not actually match what
was asked for in this brief, say so and regenerate that stage rather than accepting a close-enough
version and correcting it later once code already depends on it.

Customize

Optional — swap in your own details for the highlighted parts above.

Why this works

Copilot Workspace's own architecture is three separate, individually editable steps — specification, plan, and implementation — precisely so a human can validate what the tool understood and what it intends to do before a single line of code exists; a brief that never separates what must be true (acceptance criteria) from what must not change (constraints, out of scope) gives the specification step nothing to slow down for, so it collapses back toward restating the issue title in slightly more words and calling that a spec. Requiring the plan's steps to map one-to-one onto the numbered acceptance criteria turns 'does this plan look reasonable' into a checkable claim — a step that exists with no corresponding acceptance criterion is scope creep introduced at the planning stage, and a criterion with no corresponding step is a silent gap that would otherwise only surface once the PR is already open. Checking constraints individually rather than confirming the plan does not contradict them targets a specific and common failure: a plan can honor a constraint's letter while violating its intent, such as building a second parallel helper next to an existing one the constraint said to reuse, rather than removing or contradicting the existing helper outright — the second kind of violation is far more visible on a skim than the first, so a broad glance at the plan systematically under-catches it. The pilot-file requirement for anything beyond two or three files exists because Workspace's plan step reasons about dependency order in the abstract, on paper, before any code has actually been written against it — building one real file first is the cheapest possible test of whether that abstract ordering was actually right, and if it was not, the cost of finding out is one file's diff, not the full multi-file change. Finally, rejecting a spec that resolves an ambiguity without flagging it matters because a spec-generation step under no instruction to surface ambiguity will, by default, pick whichever reading is easiest to implement and present it with the same confidence as an unambiguous requirement — the review value of having a distinct spec stage at all depends entirely on being able to tell the difference between this was clear and this was resolved by guessing, and an unflagged resolution erases that distinction.

What you get back

Spec (excerpt): Add a rolling 30-day export counter checked inside the existing rate-limit middleware before the export handler runs. Files: lib/middleware/rate-limit.ts (add export-count check), lib/config/limits.ts (new EXPORT_LIMIT_FREE_TIER constant), app/api/reports/export/route.ts (return the specified 403). Flagged ambiguity: acceptance criteria 3 says configurable — read as an environment-variable-backed constant, not a per-user database override, since no admin UI was mentioned in the issue. Confirm before advancing to the plan stage.

Verified against

GitHub Copilot Workspace GA, 2026 (spec/plan/implementation stages) · 2026-07-24

Changelog

  • 2026-07-24 Initial publish, verified against GitHub Copilot Workspace GA.

Need this built into your business?

If a prompt isn't enough — custom software, built and maintained for you — that's Scult's day job.

EXPLORE CUSTOM SOFTWARE
Write a .github/copilot-instructions.md file Copilot actually followsA repository-wide custom-instructions file that Copilot loads automatically into every Chat request, code-review pass, coding-agent session, and commit or PR-description generation in this repo, written so each rule holds up standing alone instead of only in the context it was written in.GitHub Copilot Chat (VS Code)GitHub Copilot code review2026-07-20Scope Copilot's instructions to one directory with an applyTo instructions fileA path-scoped .github/instructions/*.instructions.md template using the applyTo frontmatter glob, so a directory-specific rule — a different test framework, a stricter API contract, a legacy pattern that must not spread — applies only where it is actually true instead of polluting the repo-wide instructions file.GitHub Copilot Chat (VS Code)GitHub Copilot coding agent2026-07-21Define a custom Copilot Chat mode instead of re-explaining your workflow every sessionA .github/chatmodes/*.chatmode.md definition — scoped tools, a fixed model, and a narrow system prompt — that turns a repeated review-and-plan style of conversation into a mode you switch into once, instead of a persona you re-describe in the first message every time.GitHub Copilot Chat (VS Code)2026-07-22Turn a prompt you keep retyping into a Copilot prompt file instead of pasting it againA .github/prompts/*.prompt.md reusable prompt file with input placeholders, invoked as a slash command from the Chat input box, so a well-tuned multi-paragraph prompt becomes one command instead of a paste you have to keep re-finding.GitHub Copilot Chat (VS Code)2026-07-22
All GitHub Copilot prompts

Check your AI visibility

One URL in, a 0–100 score and the exact fixes out.

RUN THE CHECK

Browse all the tools

15 tools across six categories
13 of them never send your data anywhere

Free · No signup · No trial clock

SEE THE DIRECTORY