Publishing platform Substack has admitted that it suffered a data breach some months ago. In an email sent out to users, company CEO Chris Best explained that the phone numbers and email addresses of some account holders had been accessed by an intruder. He says of the situation, “that sucks”, and seeks forgiveness from those affected by the security breach. What is interesting about the breach is that it is not something that has just occurred. While Best has sent the apologetic email just now, the security incident dates back to October 2025. Substack has not been sitting on information… [Continue Reading]

We have another two-for-one special this week, with two more interviews from the floor of re:Invent.

The January 2026 release of Visual Studio Code expands AI-assisted development with structured planning agents, parallel subagents, and unified orchestration across local and cloud environments.

Founders used to be wedded to their companies. Now, anyone can be lured away for the right price.

1. Introduction to OpenClaw

OpenClaw is an open-source AI personal assistant platform that runs on your own devices and executes real-world tasks. Unlike traditional cloud-based AI assistants, OpenClaw emphasizes local deployment and privacy protection, giving you complete control over your data.

Key Features of OpenClaw

• Cross-Platform Support: Runs on Windows, macOS, Linux, and other operating systems
• Multi-Channel Integration: Interact with AI through messaging platforms like WhatsApp, Telegram, and Discord
• Task Automation: Execute file operations, browser control, system commands, and more
• Persistent Memory: AI remembers your preferences and contextual information
• Flexible AI Backends: Supports multiple large language models including Anthropic Claude and OpenAI GPT

OpenClaw is built on Node.js and can be quickly installed and deployed via npm.

2. Security Advantages of Running OpenClaw on Azure VM

Deploying OpenClaw on an Azure virtual machine instead of your personal computer offers significant security benefits:

1. Environment Isolation

Azure VMs provide a completely isolated runtime environment. Even if the AI agent exhibits abnormal behavior or is maliciously exploited, it won't affect your personal computer or local data. This isolation mechanism forms the foundation of a zero-trust security architecture.

2. Network Security Controls

Through Azure Network Security Groups (NSGs), you can precisely control which IP addresses can access your virtual machine. The RDP rules configured in the deployment script allow you to securely connect to your Windows 11 VM via Remote Desktop while enabling further restrictions on access sources.

3. Data Persistence and Backup

Azure VM managed disks support automatic snapshots and backups. Even if the virtual machine encounters issues, your OpenClaw configuration and data remain safe.

4. Elastic Resource Management

You can adjust VM specifications (memory, CPU) at any time based on actual needs, or stop the VM when not in use to save costs, maintaining maximum flexibility.

5. Enterprise-Grade Authentication

Azure supports integration with Azure Active Directory (Entra ID) for identity verification, allowing you to assign different access permissions to team members for granular access control.

6. Audit and Compliance

Azure provides detailed activity logs and audit trails, making it easy to trace any suspicious activity and meet enterprise compliance requirements.

3. Deployment Steps Explained

This deployment script uses Azure CLI to automate the installation of OpenClaw and its dependencies on a Windows 11 virtual machine. Here are the detailed execution steps:

Prerequisites

Before running the script, ensure you have:

1. Install Azure CLI

# Windows users can download the MSI installer https://aka.ms/installazurecliwindows # macOS users brew install azure-cli # Linux users curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

      2. Log in to Azure Account

az login

      3. Prepare Deployment Script Save the provided deploy-windows11-vm.sh script locally and grant execute permissions:

chmod +x deploy-windows11-vm.sh

Step 1: Configure Deployment Parameters

The script begins by defining key configuration variables that you can modify as needed:

RESOURCE_GROUP="Your Azure Resource Group Name" # Resource group name VM_NAME="win11-openclaw-vm" # Virtual machine name LOCATION="Your Azure Regison Name" # Azure region ADMIN_USERNAME="Your Azure VM Administrator Name" # Administrator username ADMIN_PASSWORD="our Azure VM Administrator Password" # Administrator password (change to a strong password) VM_SIZE="Your Azure VM Size" # VM size (4GB memory)

Security Recommendations:

• Always change ADMIN_PASSWORD to your own strong password
• Passwords should contain uppercase and lowercase letters, numbers, and special characters
• Never commit scripts containing real passwords to code repositories

Step 2: Check and Create Resource Group

The script first checks if the specified resource group exists, and creates it automatically if it doesn't:

echo "Checking resource group $RESOURCE_GROUP..." az group show --name $RESOURCE_GROUP &> /dev/null if [ $? -ne 0 ]; then echo "Creating resource group $RESOURCE_GROUP..." az group create --name $RESOURCE_GROUP --location $LOCATION fi

A resource group is a logical container in Azure used to organize and manage related resources. All associated resources (VMs, networks, storage, etc.) will be created within this resource group.

Step 3: Create Windows 11 Virtual Machine

This is the core step, using the az vm create command to create a Windows 11 Pro virtual machine:

az vm create \ --resource-group $RESOURCE_GROUP \ --name $VM_NAME \ --image MicrosoftWindowsDesktop:windows-11:win11-24h2-pro:latest \ --size $VM_SIZE \ --admin-username $ADMIN_USERNAME \ --admin-password $ADMIN_PASSWORD \ --public-ip-sku Standard \ --nsg-rule RDP

Parameter Explanations:

• --image: Uses the latest Windows 11 24H2 Professional edition image
• --size: Standard_B2s provides 2 vCPUs and 4GB memory, suitable for running OpenClaw
• --public-ip-sku Standard: Assigns a standard public IP
• --nsg-rule RDP: Automatically creates network security group rules allowing RDP (port 3389) inbound traffic

Step 4: Retrieve Virtual Machine Public IP

After VM creation completes, the script retrieves its public IP address:

PUBLIC_IP=$(az vm show -d -g $RESOURCE_GROUP -n $VM_NAME --query publicIps -o tsv) echo "VM Public IP: $PUBLIC_IP"

This IP address will be used for subsequent RDP remote connections.

Step 5: Install Chocolatey Package Manager

Using az vm run-command to execute PowerShell scripts inside the VM, first installing Chocolatey:

az vm run-command invoke -g $RESOURCE_GROUP -n $VM_NAME --command-id RunPowerShellScript \ --scripts "Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString( 'https://community.chocolatey.org/install.ps1'))"

Chocolatey is a package manager for Windows, similar to apt or yum on Linux, simplifying subsequent software installations.

Step 6: Install Git

Git is a dependency for many npm packages, especially those that need to download source code from GitHub for compilation:

az vm run-command invoke -g $RESOURCE_GROUP -n $VM_NAME --command-id RunPowerShellScript \ --scripts "C:\ProgramData\chocolatey\bin\choco.exe install git -y"

Step 7: Install CMake and Visual Studio Build Tools

Some of OpenClaw's native modules require compilation, necessitating the installation of C++ build toolchain:

az vm run-command invoke -g $RESOURCE_GROUP -n $VM_NAME --command-id RunPowerShellScript \ --scripts "C:\ProgramData\chocolatey\bin\choco.exe install cmake visualstudio2022buildtools visualstudio2022-workload-vctools -y"

Component Descriptions:

• cmake: Cross-platform build system
• visualstudio2022buildtools: VS 2022 Build Tools
• visualstudio2022-workload-vctools: C++ development toolchain

Step 8: Install Node.js LTS

Install the Node.js Long Term Support version, which is the core runtime environment for OpenClaw:

az vm run-command invoke -g $RESOURCE_GROUP -n $VM_NAME --command-id RunPowerShellScript \ --scripts "$env:Path = [System.Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path','User'); C:\ProgramData\chocolatey\bin\choco.exe install nodejs-lts -y"

The script refreshes environment variables first to ensure Chocolatey is in the PATH, then installs Node.js LTS.

Step 9: Globally Install OpenClaw

Use npm to globally install OpenClaw:

az vm run-command invoke -g $RESOURCE_GROUP -n $VM_NAME --command-id RunPowerShellScript \ --scripts "$env:Path = [System.Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path','User'); npm install -g openclaw"

Global installation makes the openclaw command available from anywhere in the system.

Step 10: Configure Environment Variables

Add Node.js and npm global paths to the system PATH environment variable:

az vm run-command invoke -g $RESOURCE_GROUP -n $VM_NAME --command-id RunPowerShellScript \ --scripts " $npmGlobalPath = 'C:\Program Files\nodejs'; $npmUserPath = [System.Environment]::GetFolderPath('ApplicationData') + '\npm'; $currentPath = [System.Environment]::GetEnvironmentVariable('Path', 'Machine'); if ($currentPath -notlike \"*$npmGlobalPath*\") { $newPath = $currentPath + ';' + $npmGlobalPath; [System.Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine'); Write-Host 'Added Node.js path to system PATH'; } if ($currentPath -notlike \"*$npmUserPath*\") { $newPath = [System.Environment]::GetEnvironmentVariable('Path', 'Machine') + ';' + $npmUserPath; [System.Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine'); Write-Host 'Added npm global path to system PATH'; } Write-Host 'Environment variables updated successfully!'; "

This ensures that node, npm, and openclaw commands can be used directly even in new terminal sessions.

Step 11: Verify Installation

The script finally verifies that all software is correctly installed:

az vm run-command invoke -g $RESOURCE_GROUP -n $VM_NAME --command-id RunPowerShellScript \ --scripts "$env:Path = [System.Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path','User'); Write-Host 'Node.js version:'; node --version; Write-Host 'npm version:'; npm --version; Write-Host 'openclaw:'; npm list -g openclaw"

Successful output should look similar to:

Node.js version: v20.x.x npm version: 10.x.x openclaw: openclaw@x.x.x

Step 12: Connect to Virtual Machine

After deployment completes, the script outputs connection information:

============================================ Deployment completed! ============================================ Resource Group: Your Azure Resource Group Name VM Name: win11-openclaw-vm Public IP: xx.xx.xx.xx Admin Username: Your Administrator UserName VM Size: Your VM Size Connect via RDP: mstsc /v:xx.xx.xx.xx ============================================

Connection Methods:

Windows Users:

1. Press Win + R to open Run dialog
2. Enter mstsc /v:public_ip and press Enter
3. Log in using the username and password set in the script

macOS Users:

1. Download "Windows App" from the App Store
2. Add PC connection with the public IP
3. Log in using the username and password set in the script

Linux Users:

# Use Remmina or xfreerdp xfreerdp /u:username /v:public_ip

Step 13: Initialize OpenClaw

After connecting to the VM, run the following in PowerShell or Command Prompt

# Initialize OpenClaw openclaw onboard # Configure AI model API key # Edit configuration file: C:\Users\username\.openclaw\openclaw.json notepad $env:USERPROFILE\.openclaw\openclaw.json

Add your AI API key in the configuration file:

{ "agents": { "defaults": { "model": "Your Model Name", "apiKey": "your-api-key-here" } } }

Step 14: Start OpenClaw

# Start Gateway service openclaw gateway # In another terminal, connect messaging channels (e.g., WhatsApp) openclaw channels login

Follow the prompts to scan the QR code and connect OpenClaw to your messaging app.

4. Summary

Through this guide, we've successfully implemented the complete process of automatically deploying OpenClaw on an Azure Windows 11 virtual machine. The entire deployment process is highly automated, completing everything from VM creation to installing all dependencies and OpenClaw itself through a single script.

Key Takeaways

1. Automation Benefits: Using az vm run-command allows executing configuration scripts immediately after VM creation without manual RDP login
2. Dependency Management: Chocolatey simplifies the Windows package installation workflow
3. Environment Isolation: Running AI agents on cloud VMs protects local computers and data
4. Scalability: Scripted deployment facilitates replication and team collaboration, easily deploying multiple instances

Cost Optimization Tips

• Standard_B2s VMs cost approximately $0.05/hour (~$37/month) on pay-as-you-go pricing
• When not in use, stop the VM to only pay for storage costs
• Consider Azure Reserved Instances to save up to 72%

Security Hardening Recommendations

1. Change Default Port: Modify RDP port from 3389 to a custom port
2. Enable JIT Access: Use Azure Security Center's just-in-time access feature
3. Configure Firewall Rules: Only allow specific IP addresses to access
4. Regular System Updates: Enable automatic Windows Updates
5. Use Azure Key Vault: Store API keys in Key Vault instead of configuration files

5. Additional Resources

Official Documentation

• OpenClaw Website: https://openclaw.ai
• OpenClaw GitHub: https://github.com/openclaw/openclaw
• OpenClaw Documentation: https://docs.openclaw.ai
• Azure CLI Documentation: https://docs.microsoft.com/cli/azure/

Azure Resources

• Azure VM Pricing Calculator: https://azure.microsoft.com/pricing/calculator/
• Azure Free Account: https://azure.microsoft.com/free/ (new users receive $200 credit)
• Azure Security Center: https://azure.microsoft.com/services/security-center/
• Azure Key Vault: https://azure.microsoft.com/services/key-vault/

From Zero to 16 Games in 2 Hours: Teaching Prompt Engineering to Students with GitHub Copilot CLI

Introduction

What happens when you give a room full of 14-year-olds access to AI-powered development tools and challenge them to build games? You might expect chaos, confusion, or at best, a few half-working prototypes. Instead, we witnessed something remarkable: 16 fully functional HTML5 games created in under two hours, all from students with varying programming experience.

This wasn't magic, it was the power of GitHub Copilot CLI combined with effective prompt engineering. By teaching students to communicate clearly with AI, we transformed a traditional coding workshop into a rapid prototyping session that exceeded everyone's expectations. The secret weapon? A technique called "one-shot prompting" that enables anyone to generate complete, working applications from a single, well-crafted prompt.

In this article, we'll explore how we structured this workshop using CopilotCLI-OneShotPromptGameDev, a methodology designed to teach prompt engineering fundamentals while producing tangible, exciting results. Whether you're an educator planning STEM workshops, a developer exploring AI-assisted coding, or simply curious about how young people can leverage AI tools effectively, this guide provides a practical blueprint you can replicate.

What is GitHub Copilot CLI?

GitHub Copilot CLI extends the familiar Copilot experience beyond your code editor into the command line. While Copilot in VS Code suggests code completions as you type, Copilot CLI allows you to have conversational interactions with AI directly in your terminal. You describe what you want to accomplish in natural language, and the AI responds with shell commands, explanations, or in our case, complete code files.

 

This terminal-based approach offers several advantages for learning and rapid prototyping. Students don't need to configure complex IDE settings or navigate unfamiliar interfaces. They simply type their request, review the AI's output, and iterate. The command line provides a transparent view of exactly what's happening, no hidden abstractions or magical "autocomplete" that obscures the learning process.

For our workshop, Copilot CLI served as a bridge between students' creative ideas and working code. They could describe a game concept in plain English, watch the AI generate HTML, CSS, and JavaScript, then immediately test the result in a browser. This rapid feedback loop kept engagement high and made the connection between language and code tangible.

Installing GitHub Copilot CLI

Setting up Copilot CLI requires a few straightforward steps. Before the workshop, we ensured all machines were pre-configured, but students also learned the installation process as part of understanding how developer tools work.

First, you'll need Node.js installed on your system. Copilot CLI runs as a Node package, so this is a prerequisite:

# Check if Node.js is installed
node --version

# If not installed, download from https://nodejs.org/
# Or use a package manager:
# Windows (winget)
winget install OpenJS.NodeJS.LTS

# macOS (Homebrew)
brew install node

# Linux (apt)
sudo apt install nodejs npm

These commands verify your Node.js installation or guide you through installing it using your operating system's preferred package manager.

Next, install the GitHub CLI, which provides the foundation for Copilot CLI:

# Windows
winget install GitHub.cli

# macOS
brew install gh

# Linux
sudo apt install gh

This installs the GitHub command-line interface, which handles authentication and provides the framework for Copilot integration.

With GitHub CLI installed, authenticate with your GitHub account:

gh auth login

This command initiates an interactive authentication flow that connects your terminal to your GitHub account, enabling access to Copilot features.

Finally, install the Copilot CLI extension:

gh extension install github/gh-copilot

This adds Copilot capabilities to your GitHub CLI installation, enabling the conversational AI features we'll use for game development.

Verify the installation by running:

gh copilot --help

If you see the help output with available commands, you're ready to start prompting. The entire setup takes about 5-10 minutes on a fresh machine, making it practical for classroom environments.

Understanding One-Shot Prompting

Traditional programming education follows an incremental approach: learn syntax, understand concepts, build small programs, gradually tackle larger projects. This method is thorough but slow. One-shot prompting inverts this model—you start with the complete vision and let AI handle the implementation details.

A one-shot prompt provides the AI with all the context it needs to generate a complete, working solution in a single response. Instead of iteratively refining code through multiple exchanges, you craft one comprehensive prompt that specifies requirements, constraints, styling preferences, and technical specifications. The AI then produces complete, functional code.

This approach teaches a crucial skill: clear communication of technical requirements. Students must think through their entire game concept before typing. What does the game look like? How does the player interact with it? What happens when they win or lose? By forcing this upfront thinking, one-shot prompting develops the same analytical skills that professional developers use when writing specifications or planning architectures.

The technique also demonstrates a powerful principle: with sufficient context, AI can handle implementation complexity while humans focus on creativity and design. Students learned they could create sophisticated games without memorizing JavaScript syntax—they just needed to describe their vision clearly enough for the AI to understand.

Crafting Effective Prompts for Game Development

The difference between a vague prompt and an effective one-shot prompt is the difference between frustration and success. We taught students a structured approach to prompt construction that consistently produced working games.

Start with the game type and core mechanic. Don't just say "make a game"—specify what kind:

Create a complete HTML5 game where the player controls a spaceship 
that must dodge falling asteroids.

This opening establishes the fundamental gameplay loop: control a spaceship, avoid obstacles. The AI now has a clear mental model to work from.

Add visual and interaction details. Games are visual experiences, so specify how things should look and respond:

Create a complete HTML5 game where the player controls a spaceship 
that must dodge falling asteroids. The spaceship should be a blue 
triangle at the bottom of the screen, controlled by left and right 
arrow keys. Asteroids are brown circles that fall from the top at 
random positions and increasing speeds.

These additions provide concrete visual targets and define the input mechanism. The AI can now generate specific CSS colors and event handlers.

Define win/lose conditions and scoring:

Create a complete HTML5 game where the player controls a spaceship 
that must dodge falling asteroids. The spaceship should be a blue 
triangle at the bottom of the screen, controlled by left and right 
arrow keys. Asteroids are brown circles that fall from the top at 
random positions and increasing speeds. Display a score that increases 
every second the player survives. The game ends when an asteroid hits 
the spaceship, showing a "Game Over" screen with the final score and 
a "Play Again" button.

This complete prompt now specifies the entire game loop: gameplay, scoring, losing, and restarting. The AI has everything needed to generate a fully playable game.

The formula students learned: Game Type + Visual Description + Controls + Rules + Win/Lose + Score = Complete Game Prompt.

Running the Workshop: Structure and Approach

Our two-hour workshop followed a carefully designed structure that balanced instruction with hands-on creation. We partnered with University College London and students access to GitHub Education to access resources specifically designed for classroom settings, including student accounts with Copilot access and amazing tools like VSCode and Azure for Students and for Schools VSCode Education.

 

The first 20 minutes covered fundamentals: what is AI, how does Copilot work, and why does prompt quality matter? We demonstrated this with a live example, showing how "make a game" produces confused output while a detailed prompt generates playable code. This contrast immediately captured students' attention, they could see the direct relationship between their words and the AI's output.

The next 15 minutes focused on the prompt formula. We broke down several example prompts, highlighting each component: game type, visuals, controls, rules, scoring. Students practiced identifying these elements in prompts before writing their own. This analysis phase prepared them to construct effective prompts independently.

The remaining 85 minutes were dedicated to creation. Students worked individually or in pairs, brainstorming game concepts, writing prompts, generating code, testing in browsers, and iterating. Instructors circulated to help debug prompts (not code an important distinction) and encourage experimentation.

We deliberately avoided teaching JavaScript syntax. When students encountered bugs, we guided them to refine their prompts rather than manually fix code. This maintained focus on the core skill: communicating with AI effectively. Surprisingly, this approach resulted in fewer bugs overall because students learned to be more precise in their initial descriptions.

Student Projects: The Games They Created

The diversity of games produced in 85 minutes of building time amazed everyone present. Students didn't just follow a template, they invented entirely new concepts and successfully communicated them to Copilot CLI.

One student created a "Fruit Ninja" clone where players clicked falling fruit to slice it before it hit the ground. Another built a typing speed game that challenged players to correctly type increasingly difficult words against a countdown timer. A pair of collaborators produced a two-player tank battle where each player controlled their tank with different keyboard keys.

Several students explored educational games: a math challenge where players solve equations to destroy incoming meteors, a geography quiz with animated maps, and a vocabulary builder where correct definitions unlock new levels. These projects demonstrated that one-shot prompting isn't limited to entertainment, students naturally gravitated toward useful applications.

The most complex project was a procedurally generated maze game with fog-of-war mechanics. The student spent extra time on their prompt, specifying exactly how visibility should work around the player character. Their detailed approach paid off with a surprisingly sophisticated result that would typically require hours of manual coding.

By the session's end, we had 16 complete, playable HTML5 games. Every student who participated produced something they could share with friends and family a tangible achievement that transformed an abstract "coding workshop" into a genuine creative accomplishment.

Key Benefits of Copilot CLI for Rapid Prototyping

Our workshop revealed several advantages that make Copilot CLI particularly valuable for rapid prototyping scenarios, whether in educational settings or professional development.

Speed of iteration fundamentally changes what's possible. Traditional game development requires hours to produce even simple prototypes. With Copilot CLI, students went from concept to playable game in minutes. This compressed timeline enables experimentation, if your first idea doesn't work, try another. This psychological freedom to fail fast and try again proved more valuable than any technical instruction.

Accessibility removes barriers to entry. Students with no prior coding experience produced results comparable to those who had taken programming classes. The playing field leveled because success depended on creativity and communication rather than memorized syntax. This democratization of development opens doors for students who might otherwise feel excluded from technical fields.

Focus on design over implementation teaches transferable skills. Whether students eventually become programmers, designers, product managers, or pursue entirely different careers, the ability to clearly specify requirements and think through complete systems applies universally. They learned to think like system designers, not just coders.

The feedback loop keeps engagement high. Seeing your words transform into working software within seconds creates an addictive cycle of creation and testing. Students who typically struggle with attention during lectures remained focused throughout the building session. The immediate gratification of seeing their games work motivated continuous refinement.

Debugging through prompts teaches root cause analysis. When games didn't work as expected, students had to analyze what they'd asked for versus what they received. This comparison exercise developed critical thinking about specifications a skill that serves developers throughout their careers.

Tips for Educators: Running Your Own Workshop

If you're planning to replicate this workshop, several lessons from our experience will help ensure success.

Pre-configure machines whenever possible. While installation is straightforward, classroom time is precious. Having Copilot CLI ready on all devices lets you dive into content immediately. If pre-configuration isn't possible, allocate the first 15-20 minutes specifically for setup and troubleshoot as a group.

Prepare example prompts across difficulty levels. Some students will grasp one-shot prompting immediately; others will need more scaffolding. Having templates ranging from simple ("Create Pong") to complex (the spaceship example above) lets you meet students where they are.

Emphasize that "prompt debugging" is the goal. When students ask for help fixing broken code, redirect them to examine their prompt. What did they ask for? What did they get? Where's the gap? This redirection reinforces the workshop's core learning objective and builds self-sufficiency.

Celebrate and share widely. Build in time at the end for students to demonstrate their games. This showcase moment validates their work and often inspires classmates to try new approaches in future sessions. Consider creating a shared folder or simple website where all games can be accessed after the workshop.

Access GitHub Education resources at education.github.com before your workshop. The GitHub Education program provides free access to developer tools for students and educators, including Copilot. The resources there include curriculum materials, teaching guides, and community support that can enhance your workshop.

Beyond Games: Where This Leads

The techniques students learned extend far beyond game development. One-shot prompting with Copilot CLI works for any development task: creating web pages, building utilities, generating data processing scripts, or prototyping application interfaces. The fundamental skill, communicating requirements clearly to AI applies wherever AI-assisted development tools are used.

Several students have continued exploring after the workshop. Some discovered they enjoy the creative aspects of game design and are learning traditional programming to gain more control. Others found that prompt engineering itself interests them, they're exploring how different phrasings affect AI outputs across various domains.

For professional developers, the workshop's lessons apply directly to working with Copilot, ChatGPT, and other AI coding assistants. The ability to craft precise, complete prompts determines whether these tools save time or create confusion. Investing in prompt engineering skills yields returns across every AI-assisted workflow.

Key Takeaways

• Clear prompts produce working code: The one-shot prompting formula (Game Type + Visuals + Controls + Rules + Win/Lose + Score) reliably generates playable games from single prompts
• Copilot CLI democratizes development: Students with no coding experience created functional applications by focusing on communication rather than syntax
• Rapid iteration enables experimentation: Minutes-per-prototype timelines encourage creative risk-taking and learning from failures
• Prompt debugging builds analytical skills: Comparing intended versus actual results teaches specification writing and root cause analysis
• Sixteen games in two hours is achievable: With proper structure and preparation, young students can produce impressive results using AI-assisted development

Conclusion and Next Steps

Our workshop demonstrated that AI-assisted development tools like GitHub Copilot CLI aren't just productivity boosters for experienced programmers, they're powerful educational instruments that make software creation accessible to beginners. By focusing on prompt engineering rather than traditional syntax instruction, we enabled 14-year-old students to produce complete, functional games in a fraction of the time traditional methods would require.

The sixteen games created during those two hours represent more than just workshop outputs. They represent a shift in how we might teach technical creativity: start with vision, communicate clearly, iterate quickly. Whether students pursue programming careers or not, they've gained experience in thinking systematically about requirements and translating ideas into specifications that produce real results.

To explore this approach yourself, visit the CopilotCLI-OneShotPromptGameDev repository for prompt templates, workshop materials, and example games. For educational resources and student access to GitHub tools including Copilot, explore GitHub Education. And most importantly, start experimenting. Write a prompt, generate some code, and see what you can create in the next few minutes.

Resources

• CopilotCLI-OneShotPromptGameDev Repository - Workshop materials, prompt templates, and example games
• GitHub Education - Free developer tools and resources for students and educators
• GitHub Copilot CLI Documentation - Official installation and usage guide
• GitHub CLI - Foundation tool required for Copilot CLI
• GitHub Copilot - Overview of Copilot features and pricing