Start in your repository.

Already installed the plugin and supporting skills? Start discovery.

Before you start

Work in the application repository, not this tooling repository. Check the participant requirements, use an approved workspace, and identify the people who can approve access and architecture.

Working with an existing application?

Open its repository and point the creator to approved architecture or operating records stored elsewhere. Bring:

• The current user journey and the one addition you want to make.
• Existing API contracts and data sources, with their owners and access boundaries.
• Behavior and interfaces that must stay unchanged, including authorization.
• Deployment constraints, regression checks, and rollback ownership.

Use synthetic inputs until customer-data access is agreed. Describe how the application should behave when AI is unavailable or evidence is insufficient. Missing documentation does not prove that a control or service is absent.

Reuse existing capabilities where they fit. Any proposed replacement needs a clear requirement and a migration plan that preserves compatibility.

Set up your workspace

Run commands from your application directory unless a step says otherwise. Stop if a command fails. Inspect the error and any partial files before retrying.

Create a new repository

Skip this for an existing application. Follow its branching and approval rules instead.

mkdir my-ai-app
cd my-ai-app
git init

Install the plugin

For GitHub Copilot CLI:

copilot plugin marketplace add microsoft/frontier-agentic-cobuild-rvas
copilot plugin install agentic-cobuild@agentic-cobuild
copilot plugin list

For VS Code, add the marketplace without replacing existing entries:

{
  "chat.plugins.enabled": true,
  "chat.plugins.marketplaces": [
    "microsoft/frontier-agentic-cobuild-rvas"
  ]
}

Open Extensions, search for @agentPlugins, install Agentic Co-build, and enable it for the application workspace.

Install the supporting skills

All supporting skills below are required. Run every installation command before starting discovery.

Use Node.js 22.20.0 or newer to run the installation commands below.

Each command installs project-local copies from its upstream repository and can overwrite existing copies.

Skills from mattpocock/skills

Upstream source: mattpocock/skills.

npx --yes skills@1.7.2 add mattpocock/skills --skill grilling domain-modeling wait-what --agent github-copilot --copy --yes

Skills from microsoft/azure-skills

Upstream source: microsoft/azure-skills.

npx --yes skills@1.7.2 add microsoft/azure-skills --skill discover-azure-skills azure-enterprise-infra-planner microsoft-foundry azure-ai foundry-iq entra-agent-id entra-app-registration azure-aigateway --agent github-copilot --copy --yes

If an install fails, inspect the error, skill directories, and skills-lock.json before retrying. Preserve existing skills instead of deleting them to bypass a conflict. Installing a skill does not authorize cloud changes or commits.

Check the workspace

In CLI, use /skills and /mcp. In VS Code, use Chat: Configure Skills and the MCP server list.

Check that AI Agent Creator, Idea Forge, and Cloud Architecture Diagram are available, along with the supporting skills you installed and the Microsoft Learn MCP server. If anything is missing, check the installation error and reload the host before continuing.

Recommended model: Claude Opus 5.5. Select it in your host's model picker before starting AI Agent Creator or implementation.

Describe what you want to build

If several people hold the business context, use the discovery session guide first. Get approval before recording or processing the discussion.

Select AI Agent Creator from your host's skill picker or slash completion, using the name your host displays. Adapt one of these prompts to your application.

AI Agent Creator prompts

For a new application:

/ai-agent-creator Design an AI maintenance assistant for property managers that triages
resident requests and prepares work orders for approval. Account for our
existing enterprise identity and operating environment.

For an existing application:

/ai-agent-creator Add evidence-backed report summarization to this existing application.
Inspect its current stack, preserve established interfaces, and account
for our enterprise data-access and deployment constraints.

Your first milestone is confirmed discovery. Answer the creator's questions. Confirm discovery once you agree on the outcome, first user journey, and architecture decisions. The creator then prepares the architecture package.

The creator writes the editable diagrams, architecture, specification, and implementation plan under docs/architecture/. Review the diagrams and have an independent reviewer check the full package before approval. If either review is unavailable, explicitly accept and record the exception.

Approval ends this workflow. Start implementation separately. Approval does not change code, generate infrastructure, or provision resources.

Start implementation in a new session

Choose one workflow; do not combine them. Each uses the approved files under docs/architecture/ as its authority.

Direct from the documents

Open a new session and attach the approved architecture files. Use this path unless the work needs the extra coordination provided by the other workflows.

Read @docs/architecture/specification.md,
@docs/architecture/implementation-plan.md, @docs/architecture/solution.md,
@docs/architecture/solution.drawio, and @docs/architecture/cost-estimate.md.
Implement the approved plan in dependency order. Treat the specification and
its acceptance criteria as the requirements source of truth. Follow the
approved architecture, preserve existing interfaces and authorization, and
add focused tests for changed behavior. Run the relevant checks and report
actual results. Do not change an architecture decision without approval.
Do not commit, provision, deploy, or change production data.

Matt Pocock spec and tickets

For independent work items that need dependency tracking, install the Matt Pocock engineering workflow if /to-spec, /to-tickets, and /implement-spec are not available. Track the work in local Markdown, not remote issues.

/to-spec Convert the approved docs/architecture/ package into one bounded local
implementation spec. Preserve its requirement and acceptance IDs, architecture
decisions, interfaces, authorization, cost constraints, and out-of-scope work.
Do not implement yet.

/to-tickets Break the local spec into dependency-linked, testable tickets.
Keep every ticket linked to the original acceptance criteria. Show the proposed
breakdown before writing it. Do not publish remote issues or implement yet.

Open a new session for delivery:

/implement-spec Implement the approved local spec and tickets. Reconcile them
with the current source and the full docs/architecture/ package. Preserve the
approved architecture and existing contracts. Run focused and combined checks.
Do not push, open a pull request, provision, deploy, or change production data.

Spec Kit

Configure Spec Kit, then run its constitution, specify, clarify when needed, plan, and tasks commands against the approved docs/architecture/ package. Do not use those commands to replace settled architecture decisions.

Open a new session after the feature plan and tasks are reviewed:

/speckit-implement Implement only the reviewed feature tasks. Treat the
docs/architecture/ package and its acceptance criteria as authoritative.
Preserve the approved architecture, interfaces, authorization, and cost
constraints. Run the documented tests and record actual results. Do not commit,
provision, deploy, or change production data.

Use /speckit-converge after each implementation pass. Repeat implementation and convergence until the feature is converged or the remaining blocker is recorded.

Get approval before changing an architecture decision, whichever workflow you use.

After targeted checks pass, run the implementation and security reviews. Resolve findings and rerun affected tests. If review tooling is unavailable, assign a human reviewer and record the gap.

The operating team still owns production acceptance and rollback.

Command and prompt reference

Use these commands after implementation or when maintaining an existing setup.

Review prompts

Implementation review:

/review Review the staged and unstaged implementation against
@docs/architecture/specification.md,
@docs/architecture/implementation-plan.md, and
@docs/architecture/solution.md. Identify unmet or partially met acceptance
criteria, skipped or out-of-order plan steps, architecture deviations,
regressions, and missing tests. Rank findings by severity and include file and
line references.

Security review:

/security-review Analyze the staged and unstaged implementation for exploitable
security vulnerabilities, insecure defaults, authorization or data-isolation
failures, secret exposure, injection risks, unsafe external interactions, and
dependency or configuration weaknesses. Rank findings by severity and confidence,
include file and line references, and recommend the smallest safe fix for each
finding.

Update the plugin

Each teammate manages the plugin in their own host. Review updates before use. Supporting skill updates remain separate.

copilot plugin update agentic-cobuild

VS Code users can run the plugin update action instead.

Need an idea first?

Use Idea Forge to research an opportunity. Take the selected brief through AI Agent Creator discovery and architecture approval.

Idea Forge prompt

/idea-forge Find a bounded AI opportunity for [customer] in [industry].
Research the business and publicly stated priorities on the web.

See the plugin source and the diagram asset terms.