GitHub Copilot Enterprise Lab

Your Environment

Checking…

Setup — Do This First

Wait for VS Code to load (right panel, ~30 s). You'll see the VS Code interface appear.
GitHub Copilot is ready — no sign-in needed.
Look for the ↕ Copilot icon in the bottom status bar. It should show as active (white, not greyed out).
Open a terminal inside VS Code:
Ctrl + ` (backtick)

Go to the lab workspace:

cd /home/student/workspace/copilot-enterprise-lab

List exercises:
```
ls exercises/
```
You'll see folders 01-agent-mode through 06-token-optimisation.

01 Agent Mode

Let Copilot read a failing test and implement the full REST API on its own — you describe the goal, it writes the code.

spec.md
your requirements

→

Agent Mode
reads + plans

→

api.js
working code

Navigate to the exercise:
```
cd exercises/01-agent-mode
```
Read the spec:
```
cat README.md
```
Run the failing tests first:
```
npm test
```
You'll see several FAIL lines — that's expected.
Open Copilot Chat (Ctrl+Shift+I) and switch to Agent mode using the dropdown.

Paste this prompt:

Read the spec in README.md and the failing tests in tests/. Implement the REST API in api.js so all tests pass. Do not modify the test files.

Watch Copilot create files and write code. When done, run:
```
npm test
```
All tests should pass (✓).

02 Terminal Commands

Use Copilot in the VS Code terminal to generate bash one-liners, Docker commands, and git operations without memorising syntax.

Navigate:

cd /home/student/workspace/copilot-enterprise-lab/exercises/02-terminal

Read the tasks:
```
cat README.md
```
In the terminal, type # then describe what you want — Copilot suggests the command. Example:
Type into the terminal:
```
# find all .js files larger than 100KB and list their sizes
```
Press Tab to accept the suggestion.
Try each task in README.md using natural-language comments in the terminal. Copilot will suggest the correct command.

Example tasks:

# show git log as a pretty one-line graph
# list docker containers sorted by memory use
# count lines of code in all .js files

03 Debugging Workflow

Four real bugs are hidden in a payment-processing module. Use Copilot Chat to locate and explain each one, then fix it.

Buggy code
payment.js

→

Copilot Chat
/explain, /fix

→

Fixed code
tests pass

Navigate:

cd /home/student/workspace/copilot-enterprise-lab/exercises/03-debugging

Run tests to see which fail:
```
npm test
```
Open payment.js in the editor. Select suspicious code, then open Copilot Chat and type:
```
/explain What is wrong with this function?
```
Once you find a bug, select the code and use:
```
/fix
```
Repeat for all 4 bugs. Run npm test after each fix. All 4 tests should pass at the end.

04 Security Audit

A deliberately vulnerable Express app contains SQL injection, path traversal, hardcoded secrets, and XSS. Use Copilot to find and fix each.

Vulnerable
app.js

→

Copilot
security review

→

Secure
app.js

SQLi String concat in queries

Path Unvalidated file paths

Secret Hardcoded API keys

XSS Unsanitised HTML output

Navigate:

cd /home/student/workspace/copilot-enterprise-lab/exercises/04-security

Open app.js. In Copilot Chat, send:

Review this file for OWASP Top 10 vulnerabilities. List each one with line numbers.

For each vulnerability Copilot identifies, ask:

Fix the SQL injection on line 34 using parameterised queries.

Run the security tests after each fix:
```
npm test
```
Goal: all 4 vulnerability tests pass.

05 MCP Integration

Wire a Model Context Protocol (MCP) server into Copilot so it can call custom tools — run tests, check progress, and query a database — all from natural language.

Copilot Chat
user prompt

↔

MCP Server
your tools

↔

Test runner
/ DB / API

Copilot calls your tools automatically when relevant

Navigate:

cd /home/student/workspace/copilot-enterprise-lab/exercises/05-mcp

Read the MCP server code:
```
cat mcp-server.js
```
Start the MCP server:
```
node mcp-server.js
```

In VS Code settings, add the MCP server to Copilot. Open Command Palette (Ctrl+Shift+P) → Open MCP Settings and add:

{
  "servers": {
    "lab": {
      "type": "stdio",
      "command": "node",
      "args": ["/home/student/workspace/copilot-enterprise-lab/exercises/05-mcp/mcp-server.js"]
    }
  }
}

In Copilot Chat, try:
```
Run the tests for exercise 01 and show me what failed.
```
Copilot will call your MCP tool automatically.

06 Token Optimisation

Compare prompt strategies, measure token usage, and learn when to use inline completions vs. Chat vs. Agent Mode to maximise value and minimise cost.

Inline~50 tokens · instant

Chat~500 tokens · seconds

Agent~5 000 tokens · minutes

Pick the right mode for the task — bigger ≠ better

Navigate:

cd /home/student/workspace/copilot-enterprise-lab/exercises/06-token-optimisation

Read the README:
```
cat README.md
```
Run the provided benchmarking script:
```
node benchmark.js
```
It will show token counts for each prompt strategy.
Edit prompts.js and try rewriting prompts to reduce tokens while keeping the same quality.
Re-run to compare:
```
node benchmark.js
```
Goal: achieve the target token budget shown in README.md for each scenario.

VS Code

Click Start Lab to create your environment.
VS Code will appear here in about 30 seconds.

`Tab`	Accept inline suggestion
`Esc`	Dismiss suggestion
`Alt`+`]`	Next suggestion
`Ctrl`+`I`	Inline chat
`Ctrl`+`Shift`+`I`	Copilot Chat panel
`/explain`	Explain selected code
`/fix`	Fix selected code
`/tests`	Generate tests
`/doc`	Generate documentation

Join the Lab

VS Code