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.
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
