The Art of
the Possible.

Start here

Use the GitHub Copilot App or CLI. Prefer a visual interface? The prerequisites include an App setup route. Both use the same Accelerator prompts.

Prefer a visual guide? View the Accelerator on GitHub Pages. It includes the full guide, copyable prompts, chapter navigation, light/dark views, and print styling. For offline use, download the HTML companion and open it in a browser. GitHub's source-file viewer does not run HTML; the Pages version does.

The whole experience in three prompts

Paste prompts into Copilot. Run terminal commands in your terminal instead. Replace the entire <placeholder>, including the angle brackets.

Discover

Use the ait-idea skill to find 2 business use cases for <Company>
from <https://www.company.com>.

Build

Use the ait-product-showcase skill to build an executive showcase prototype
from use case 01 in docs. Use its brief as the product requirements, with
its one-pager and research as narrative, brand and evidence context—not
a UI to reproduce.

Refine

Make the business reveal more compelling: <what the user should understand
or be able to do>. Use the ait-product-showcase skill to refine the
existing prototype within its brief and update Simulate.

For the unattended chain, use the autopilot prompt after completing setup. It connects the two skills without restating their workflows.

What you will have

In your own workspace's docs folder, not this repository's documentation:

• A cited research dossier with company context, evidence classes, brand guidance, and ranked ideas.
• Two company-styled HTML one-pagers and two Markdown prototype briefs.
• One self-contained <product>-v1.html showcase with realistic simulated data, working interactions, and a Simulate tour with narration, transcript, and controls.
• Verification and review findings, with an honest READY or BLOCKED outcome.

Readiness is earned, not guaranteed by elapsed time. A workshop agenda can provide checkpoints, but must never turn an unfinished draft into an executive-ready deliverable.

The executive bar

The wow is a business reveal, not an animation: something previously slow, difficult, or hard to see becomes understandable or actionable in the demonstration.

Before presenting, ask: Would I stand in front of this CEO and present it myself? Could I defend the evidence, explain what is simulated, and show why the idea matters?

Both final showcase critics must agree. If the review budget runs out first, report the remaining concerns and mark the showcase BLOCKED, not done.

Scope and boundaries

Use public, non-personal source information and invented demo people in this Accelerator. Do not include private documents, credentials, personal records, or internal integrations. No publishing, committing, deployment, or production implementation is part of the core run. PDF and PowerPoint exports are optional. New prototype versions and expanded scope are your decision.

The ideation skill and showcase skill own the workflow and review criteria; these pages explain how to use them, not replace them.

Finish setup before starting discovery. Choose GitHub Copilot App for a visual interface or GitHub Copilot CLI for a terminal. The Accelerator prompts and readiness criteria are the same; installation and session controls differ.

Neither route requires document skills unless you want an optional PDF or PowerPoint.

Option A: GitHub Copilot App

1. Install and sign in

Download the GitHub Copilot App and install Git. Open the App, choose Sign in to GitHub, and complete onboarding with your Copilot account. Organizational App policy is separate from CLI policy; contact your administrator if access is blocked.

The local Playwright MCP server also needs Node.js LTS and a supported installed browser. PowerShell 7 and the separate CLI installation are not requirements for this App route.

2. Add the team plugin

Open Customize > Plugins. Use the icon next to the marketplace dropdown to add CalinL/ai-team-sdlc, then find ai-team-sdlc and select Install. If already installed, confirm its version rather than installing another copy.

3. Add or check the browser tool

Open Customize > MCP and check Installed first. GitHub documents that skills and MCP servers configured for your repositories or Copilot CLI are also available in the App; verify they load rather than adding duplicate configuration.

If Playwright is missing, add a custom local MCP server. For the Windows/Edge recipe, use command npx with arguments -y @playwright/mcp@latest --browser msedge. This runs the public Playwright MCP package; use it only where permitted. For other platforms, choose a supported installed browser from the Playwright reference below.

If you prefer configuring through a terminal and already have the CLI, the Playwright command under CLI step 2 is an alternative—not an extra App prerequisite. Restart the session if new tools or skills do not appear.

4. Connect your workspace and start a session

Create a fresh folder outside the plugin repository using your file manager. Initialize it as a Git repository by running git init in a terminal opened in that folder. Git is already a prerequisite; this does not require Copilot CLI or PowerShell 7. The repository makes ideation's default docs output match the showcase handoff.

In the App, use the add-project control beside Projects, choose Local folder or repository, and select that folder.

Below the prompt field, choose execution in the local repository, not a new working tree or cloud sandbox, so the documented docs path stays in your chosen folder. Choose Interactive initially and a capable model. Run the shared setup check in that project's agent session, not in a general Chat.

For the fast track, select Autopilot from the mode picker after checking permissions; /autopilot is also available. Tool auto-approval is a separate setting, not a prerequisite to enable blindly. If permissions cannot be safely authorized, stay Interactive and use the guided route. The CLI continuation-limit flag below is not an App setup command.

Then go to the Accelerator guide. The same skill prompts apply.

App references: Quickstart | Plugins, skills and MCP | Session location, mode and model.

Option B: GitHub Copilot CLI

1. Check access and install the essentials

You need a GitHub account with access to Copilot CLI, permission to use the required tools, and internet access for public research. Organizational policy and usage limits can affect availability. Check the official CLI quickstart for current requirements and installation options.

The Windows recipe uses PowerShell 7, Git, Node.js LTS, and an installed Microsoft Edge browser. Git is used to create your local working repository; Node.js runs the Playwright MCP server. Python and document-generation plugins are not core prerequisites.

Windows terminal commands - install missing tools only:

winget install --id Microsoft.PowerShell -e
winget install --id Git.Git -e
winget install --id OpenJS.NodeJS.LTS -e
winget install --id GitHub.Copilot -e

Run one command at a time and resolve any errors. If installations are restricted, use your approved installation route rather than bypassing policy.

Close and reopen Terminal, start PowerShell 7 with pwsh, then check:

copilot --version
git --version
node --version

On macOS or Linux, use the official quickstart's platform instructions. Do not paste the Windows commands into a different shell.

Start copilot, complete sign-in when prompted (or use /login), and exit with /exit before configuring the tools below.

2. Install the team and browser tool

Terminal commands:

copilot plugin marketplace add CalinL/ai-team-sdlc
copilot plugin install ai-team-sdlc@ai-team-sdlc

Already installed? Update rather than reinstall:

copilot plugin update ai-team-sdlc@ai-team-sdlc

For the Windows recipe, add Playwright MCP using Edge:

copilot mcp add playwright -- npx -y @playwright/mcp@latest --browser msedge

This command downloads and runs the public Playwright MCP package. Use it only where permitted. If an MCP server named playwright already exists, inspect its configuration using /mcp rather than creating a conflicting entry.

Other platforms can use a supported installed browser; follow the Playwright MCP configuration. The browser tool and web research are separate checks: opening a page does not prove that research is available.

3. Create a fresh workspace

Create an empty folder outside this plugin repository and outside sensitive working folders. The following example creates a uniquely named local workspace; it does not clone the plugin.

Windows PowerShell commands:

$workspace = Join-Path $HOME ("art-of-the-possible-" + (Get-Date -Format "yyyyMMdd-HHmmss"))
New-Item -ItemType Directory -Path $workspace -ErrorAction Stop
Set-Location $workspace
git init
copilot

Confirm that Copilot is working in this folder. All generated files go in its docs subfolder. ait-init is not required for direct skill use; do not configure adoption unless you intend to.

A folder is not a sandbox. For the guided route, leave ordinary permissions in place and approve only the access needed for the task. Inspect /permissions and, where supported, /sandbox. Do not connect private-data tools. The fast track has a separate permission decision, explained below; broad permission approval is never an automatic setup step.

4. Prove the core path works

Shared check: CLI users paste into the active CLI session; App users paste into the connected project's Interactive agent session. No different prompt is needed.

Paste this prompt into Copilot before starting the Accelerator: Replace <https://www.company.com> with your target company's actual public site.

Check setup only: confirm ait-idea and ait-product-showcase load, fetch
<https://www.company.com>, and use Playwright MCP to open both that page
and a temporary local HTML file. Remove your temporary file afterward.
Report passed, failed or unavailable checks and whether independent
review subagents are available. Do not start discovery or a showcase.

Ready to start when: both skills load, research works, the MCP browser opens both web and local HTML, and you know which review capabilities are available.

Two independent reviewers are required for the unattended showcase path. Ideation permits its documented, disclosed self-review fallback when reviewers are unavailable, but that does not silently satisfy the showcase's independent-review requirement.

If a core check fails, use troubleshooting before spending time on a build.

Choose the mode and model

App: use the model and mode pickers below the prompt field. CLI: use /model; for the fast track, enable /autopilot. No particular model version is required. Research, builds, and repeated reviews consume your allowance. Check /usage and applicable limits before a long run.

The following permission and continuation details describe the CLI. Autopilot controls continuation; it does not itself grant all permissions. When entering the mode, the CLI may ask whether to enable all permissions, use manual approval, or cancel. In autopilot, manual approval automatically denies requests that still need approval rather than pausing for you to approve them. The chain can therefore become blocked.

For an unattended run, review the official permission guidance and deliberately decide whether broad permissions are acceptable in your environment. Consider supported sandboxing first and verify that browser and workspace access still work inside it. Never assume the workspace folder limits access. If you cannot safely authorize the required actions, cancel autopilot and use the guided interactive route instead.

Autopilot can also pause at its continuation limit (currently five continuations by default). The --max-autopilot-continues launch option changes that limit; check current CLI help before adjusting it. Continuation limits are separate from the skills' three-round review budgets. Do not reset a review budget to resume a paused session. Stop unexpected work with Esc twice in the CLI.

Other interfaces

• VS Code Copilot: use the installed skills or /product-idea and /product-showcase wrappers when available. Confirm installation and browser configuration in VS Code; the CLI's MCP setup is not a promise that another interface is configured.
• GitHub Copilot App: use the App route above; no separate Accelerator prompts are needed.
• Another agent host: the ideation skill is self-contained and can be pasted in. Transfer its dossier, selected brief, and one-pager together into the showcase workspace. The full showcase still requires its companion skills, assets, browser tooling, and review capability.

Setup references

• App download
• App quickstart
• App customization
• App session controls
• App slash commands
• CLI quickstart
• Plugin installation
• MCP configuration
• Autopilot and permissions
• Tool permissions

Choose one route: run the fast track, or work through the guided steps. Do not send the separate discovery/build prompts while the chained prompt is already running. Replace whole placeholders. Prompts go into Copilot, not the terminal. Replace the company, website and chosen case number yourself. Copilot chooses the product filename; you do not need to supply a slug.

Let the skills do their job. Prompts supply the goal, inputs, and feedback. The skills already define design, verification, review, Simulate, versioning, and readiness; do not paste a second workflow over them. The handoff notes below explain how to interpret the inputs, not replace either skill's procedure.

Fast track: one prompt

Complete setup and checks. In CLI, enable /autopilot; in the GitHub Copilot App, select Autopilot below the prompt box. Saying "autopilot" in a prompt is not a substitute for configuring the mode. Check permissions in your interface before an unattended run. In CLI, manual approval in autopilot denies requests needing approval rather than stopping to ask. Use the interactive guided route if an unattended run cannot be safely authorized.

Using the App? Keep the session in your chosen local repository, not a new working tree or cloud sandbox. Paste the same prompt below into the project's agent session.

Run on autopilot: use the ait-idea skill to find 2 business use cases for
<Company> from <https://www.company.com>. Once ideation is READY, use the
ait-product-showcase skill to build an executive showcase from use case 01
in docs. Use its brief as the product requirements, with its one-pager
and research as narrative, brand and evidence context—not a UI to reproduce.

Both skills use docs by default. The brief drives the product experience; the one-pager is the pitch, not a screen design. The skills own file naming, review and stop conditions; a NOT READY discovery must not be treated as an approved build input.

Your job while it runs: open the one-pagers and brief as they appear, understand the problem, and note what would make the pitch compelling. Do not edit files being generated. A file appearing on disk does not mean it has passed review.

Guided route

1. Discover two opportunities

Use the ait-idea skill to find 2 business use cases for <Company>
from <https://www.company.com>.

Expect a research dossier, two HTML one-pagers, and two Markdown prototype briefs. The dossier contains citations, evidence classes, brand guidance, and ranked ideas.

Check that the result is READY. Independent critics are preferred when available; the skill's self-review fallback must be disclosed if used. If ideation is NOT READY, resolve its findings before building.

2. Choose what deserves the room

The fast track builds 01. In the guided route, you may choose a different numbered case. Read its one-pager and brief and answer:

1. Who is the user, and what business friction are they facing?
2. Is that friction confirmed, an industry hypothesis, or an inference?
3. What happens on screen that makes the idea worth exploring?
4. What evidence supports the company's strategic fit?
5. What would the CEO challenge first?

Prefer one convincing reveal to many disconnected features. AI or agents are useful only when they earn their place; a good business idea does not need an agentic label.

Already have a brief? Skip discovery. Describe the user, problem, scope, screen flow, sample data, and intended reveal. Provide public-safe evidence and brand guidance. The showcase skill still owns verification, review, and readiness.

3. Build the showcase

Use the ait-product-showcase skill to build an executive showcase from
use case <NN> in docs. Use its brief as the product requirements, with
its one-pager and research as narrative, brand and evidence context—not
a UI to reproduce.

The workflow includes design preparation, the build, browser checks, peer review, source-fidelity validation, Simulate, and final-version verification/review. The design preparation is part of showcase, not an optional business-case extra.

The one-pager is a pitch, not a UI wireframe.

4. Read while it builds

Understand the story before judging the visuals. Read the brief and note two useful changes: one that improves the business reveal, and one that makes the experience clearer. Do not start a second build in the same workspace or send duplicate build requests.

If you need a checkpoint, use:

Give me a readiness checkpoint: what exists, which checks and reviews have
passed, what remains, and any blockers.

5. Inspect, refine, replay

Open the generated docs/<product>-v1.html in a browser. Start Simulate with a click. Read the bottom transcript, test the controls actually supplied, and inspect the critical flows yourself. Speech availability depends on the browser; missing narration must leave the transcript and manual walkthrough usable.

Use focused feedback instead of asking for "more wow" without direction:

The reveal should help <persona> understand or decide <specific thing>.
Use the ait-product-showcase skill to improve <screen/interaction>
within the existing brief and update Simulate.

Act as a sceptical executive. Identify the 3 hardest questions this
prototype leaves unanswered. Suggest improvements before making changes.

After changes, ask which file was updated and refresh it. Re-test the reveal and reset/replay. A previously READY verdict does not automatically cover a changed prototype.

6. Earn the final verdict

This checklist is a participant-facing view of the skills' criteria, not a replacement:

Two separate review budgets: ideation has up to three rounds under its own contract. Showcase has three rounds total across its intermediate and final reviews, not three per pass. Each round can involve two critics; time and usage depend on the findings.

Missing reviewers: ideation can use its disclosed self-review fallback. The unattended showcase stops BLOCKED if independent reviewers are unavailable. Only explicit user action may request the showcase skill's recorded-waiver/human-review route outside this unattended track; the agent must never select or approve it itself.

Budget exhausted: report the remaining concerns and BLOCKED status. Do not restart the review counter, delete the standout feature to obtain an easy pass, or claim completion.

Authoritative criteria: Ideation review and done-loop | Showcase final-version check and acceptance.

7. Present the idea, not the machinery

A useful short presentation:

• Problem: the user, the friction, and what is evidenced versus hypothetical.
• Reveal: show the decisive interaction or Simulate highlights, not every screen.
• Next validation: explain what is simulated and which assumption needs stakeholder validation.

Do not present a BLOCKED artifact as executive-ready. It can be shown as a clearly labelled work-in-progress if the audience understands its limitations.

Facilitate a session

Prepare setup before the session. Begin with a short exemplar, then move through discovery, selection, building, and participant review. Let participants read while the AI works. Reserve time for the business pitch and questions; use progress checkpoints, not deadlines that waive gates. One complete showcase is more valuable than several unfinished builds.

For follow-up materials or production planning, see optional outputs.

Keep the standard, change the plan. A useful draft is not automatically a verified showcase. Do not bypass policy, fabricate evidence, or silently substitute tooling to finish.

A useful help prompt

I expected <result>, but <observed behavior> happened at <step/file>.
Diagnose the cause using the existing tooling and show me the smallest fix.
Tell me which readiness checks this affects. Do not silently skip them.

Copy the error text, but remove credentials or personal information before sharing it.

References

• Playwright MCP browser and file-access configuration
• GitHub MCP setup
• Tool permissions
• Showcase contract and blocked outcomes

The interactive showcase is the core deliverable. PDF and PowerPoint are optional companions, not substitutes for browser verification, peer review, or the presenter test. Do not generate them unless requested. Start from the final reviewed artifact and its sources. Do not export a BLOCKED prototype as if it were executive-ready; any draft export must explicitly retain its draft status and unresolved limitations.

Add document skills only if you want an export

The relevant skills are pdf and pptx. They may need additional runtimes/packages depending on the requested output; follow their setup instructions rather than installing document tooling for every Accelerator participant.

App: open Customize > Plugins, add anthropics/skills through the marketplace settings, then install document-skills from anthropic-agent-skills. No separate CLI installation is needed for this route.

For Copilot CLI, the document-skills plugin can be installed separately:

copilot plugin marketplace add anthropics/skills
copilot plugin install document-skills@anthropic-agent-skills

Confirm the relevant skill is available before requesting an output. Installing a plugin does not prove that all of its rendering dependencies are ready. The repository publishes the anthropic-agent-skills marketplace and document-skills entry in its marketplace manifest. If your host rejects the format or restricts marketplace access, follow its supported installation process; do not bypass policy.

A short PDF pitch

Use the pdf skill to create a concise executive leave-behind from the
reviewed showcase and its brief, one-pager and research: the problem,
the business reveal, supporting evidence, simulated capabilities and
next validation steps. Save it in docs without changing the prototype.

A three-slide PowerPoint

Use the pptx skill to create a three-slide executive leave-behind from
the reviewed showcase and its brief, one-pager and research:
1. The business problem and evidence.
2. The experience and decisive business reveal.
3. Assumptions, simulated capabilities and next validation steps.
Use the established brand guidance and save it in docs without changing
the prototype.

An exported document needs its own layout/content verification. Do not claim the HTML critics also reviewed a PDF or deck they have not seen.

Ready to move beyond the demo?

First validate the business case and scope with the relevant stakeholders. Then use ait-tech-specs to translate the approved direction into requirements, acceptance criteria and technical specifications, or explicitly request the broader ait-sdlc-orchestrate lifecycle.

This is a separate, larger delivery scope, not the next automatic Accelerator step. The prototype remains a throwaway representation of the intended experience. Production code must be implemented and verified against the chosen stack; do not promote the HTML demo to production.

The broader AI-SDLC includes implementation, QA, code review, security checks and mandatory Product Owner, Security Team and Tech Lead sign-off before deployment. Adoption through ait-init, if wanted, is an explicit configuration decision rather than a prototyping prerequisite.

Source references

• Document skills
• Technical specification skill
• Full lifecycle orchestrator
• Shared sign-off contract