- 🎯 Progressive Learning Framework
- 📋 Complete Workshop Matrix
- 🛠️ Pre-Workshop Preparation
- 🌱 Basic Workshop (90 minutes)
- 🔧 Intermediate Workshop (2 hours)
- ⚡ Advanced Track: Enterprise Patterns
- 🏢 Enterprise Track: Scalability
- 🎉 Workshop Success Framework
🎯 Transform your development workflow with AI assistance - from zero to production-ready in 90 minutes
Complete Workshop Framework:
- 🎯 Progressive Learning: From basics to production-ready solutions
- ⏱️ Time-Boxed Modules: 90 minutes basic + optional advanced tracks
- 🛠️ Hands-On Practice: Real code, real scenarios, real results
- 🤖 AI-First Approach: GitHub Copilot as your development partner
- 📈 Measurable Outcomes: 50-70% productivity improvement
🤔 Questions? Check our comprehensive Workshop FAQ covering everything from AI ethics to technical troubleshooting!
🔧 All automation scripts, code examples, and templates are available in the
/resources
directory
graph TD
A[🚀 Start Here] --> B{👤 Experience Level?}
B -->|🆕 New to AI Dev| C[📚 Preparation<br/>45 min]
B -->|👩💻 Some Experience| D[⚡ Quick Setup<br/>15 min]
B -->|🏃♂️ Ready to Code| E[🚀 Jump to Hands-On<br/>5 min]
C --> F[🌱 Basic Workshop<br/>90 min]
D --> F
E --> F
F --> G{🎯 Next Level?}
G -->|🔧 Advanced Features| H[🔧 Intermediate<br/>2 hours]
G -->|🏢 Enterprise Focus| I[⚡ Advanced<br/>3+ hours]
G -->|✅ Complete| J[🎉 Production Ready]
H --> I
I --> J
style A fill:#e1f5fe
style F fill:#e8f5e8
style J fill:#fff3e0
📚 Workshop Track | ⏱️ Duration | 🎯 Learning Focus | 👥 Target Audience | 🏆 Success Outcome |
---|---|---|---|---|
🛠️ Pre-Workshop Preparation | 15-45 min | Setup & Prerequisites | All participants | Environment ready |
🌱 Core Workshop - Module 1 | 30 min | AI-assisted coding basics | Beginners | First AI-generated code |
🚀 Core Workshop - Module 2 | 30 min | Performance optimization | All levels | Performance improvements |
🔒 Core Workshop - Module 3 | 30 min | Security best practices | All levels | Secure code patterns |
🔧 Advanced Track | 2+ hours | Enterprise integration | Intermediate+ | Production-ready solutions |
🏢 Enterprise Track | 3+ hours | Scalability & governance | Advanced | Enterprise deployment |
By the end of this workshop, you'll have:
🏗️ Deliverable | 📖 Description | 🎯 Business Value |
---|---|---|
🤖 AI-Enhanced Calculator | Production-ready calculator with AI assistance | Learn AI-assisted development |
⚡ Performance Optimized Code | String processing 10x faster | Understand optimization techniques |
🔒 Security-Hardened Database | SQL injection-proof data access | Master security best practices |
🏢 Enterprise-Ready Templates | CI/CD pipelines and configurations | Production deployment skills |
gantt
title Workshop Skill Development Timeline
dateFormat X
axisFormat %s
section AI Basics
Setup & First Code :milestone, 0, 0
AI Code Generation :active, 0, 30
Code Understanding :30, 30
section Optimization
Performance Analysis :milestone, 60, 0
AI-Assisted Optimization :60, 30
section Security
Vulnerability Detection :milestone, 90, 0
Security Hardening :90, 30
section Production
Enterprise Patterns :milestone, 120, 0
Production Deployment :120, 60
⏱️ Time | 🎯 Skill Level | 📚 Focus Area | 🏆 Achievement |
---|---|---|---|
0-30 min | 🆕 Beginner | AI tool setup and first code | Working GitHub Copilot |
30-60 min | 🔰 Novice | Code optimization patterns | 10x performance improvement |
60-90 min | 🥈 Intermediate | Security best practices | Secure, production-ready code |
90+ min | 🥇 Advanced | Enterprise integration | Full deployment pipeline |
🎯 Goal: Build a powerful, AI-enhanced development environment from scratch
🎯 Objective | 📖 Description |
---|---|
🔧 Tool Setup | Complete workshop preparation and tool installation |
🚀 First Optimization | Create your first AI-assisted code optimization |
💪 Copilot Mastery | Master GitHub Copilot through hands-on practice |
⚡ Workflow Design | Establish efficient AI-powered development workflows |
- ⚙️ Development Environment Setup and Configuration
- 🔐 GitHub Copilot Installation and Authentication
- 🎯 First AI-Assisted Coding Exercises
- ⚡ Development Workflow Optimization
🎯 Goal: Create intelligent code optimization and security improvements with AI
🎯 Objective | 📖 Description |
---|---|
⚡ Performance | Implement AI-assisted performance optimization techniques |
🔒 Security | Learn vulnerability detection and automated remediation |
📈 Quality | Use AI for comprehensive code quality improvements |
🎯 Practical Skills | Build real-world AI-assisted development expertise |
- ⚡ Performance Optimization Strategies
- 🔒 Security Vulnerability Assessment and Fixes
- 📈 Code Quality Improvement Techniques
- 🐛 AI-Assisted Debugging and Testing
🎯 Goal: Master advanced GitHub Copilot features and multi-agent coordination
🎯 Objective | 📖 Description |
---|---|
💬 Advanced Chat | Master Copilot Chat and workspace features |
🔄 Custom Workflows | Implement custom AI workflows and automation |
🎨 Code Patterns | Learn advanced code generation patterns |
🤝 Multi-Agent | Understand multi-agent collaboration architectures |
- 💬 Advanced GitHub Copilot Features
- 🔄 AI Workflow Automation
- 🎨 Code Generation Best Practices
- 🤝 Multi-Agent System Design
🎯 Goal: Implement enterprise-level AI integration and governance
🎯 Objective | 📖 Description |
---|---|
🔄 CI/CD Integration | Integrate AI tools into continuous delivery pipelines |
☁️ Azure AI Services | Leverage Azure AI for enhanced development capabilities |
📋 Governance | Implement enterprise governance and compliance frameworks |
📈 Scalability | Design scalable AI-powered DevOps solutions |
- 🔄 CI/CD Pipeline Integration with AI Tools
- 📁 Reference:
/resources/intermediate/module5-cicd/azure-devops-pipeline.yml
- Complete Azure DevOps pipeline - 📁 Reference:
/resources/intermediate/module5-cicd/github-actions-workflow.yml
- GitHub Actions workflow
- 📁 Reference:
- ☁️ Azure AI Services Integration
- 📁 Reference:
/resources/common/setup/setup-azure-infrastructure.sh
- Automated setup script
- 📁 Reference:
- 📋 Enterprise Governance and Compliance
- 📈 Scalability and Performance Considerations
🎯 Goal: Deploy production-ready AI-powered DevOps solutions
🎯 Objective | 📖 Description |
---|---|
🤖 Coding Agent | Set up and configure GitHub Copilot Coding Agent |
🔄 Autonomous Workflows | Implement fully autonomous development workflows |
🤝 Collaboration | Master multi-agent collaboration patterns |
🚀 Production Deploy | Deploy production-ready AI-powered DevOps solutions |
- 🤖 GitHub Copilot Coding Agent Configuration
- 🔄 Autonomous Workflow Implementation
- 📁 Reference:
/resources/intermediate/module7-multi-agent/multi_agent_orchestrator.py
- Multi-agent system example
- 📁 Reference:
- 🚀 Production Deployment Strategies
- 📁 Reference:
/resources/intermediate/module5-cicd/azure-devops-pipeline.yml
- Production pipeline
- 📁 Reference:
- 📊 Monitoring and Optimization of AI-Powered Systems
🎯 Goal: Optimize AI-powered solutions for production environments
🎯 Objective | 📖 Description |
---|---|
📊 Monitoring | Implement comprehensive performance monitoring |
🚨 Incident Response | Set up AI-powered incident response systems |
🔄 Continuous Improvement | Establish ongoing optimization processes |
🏆 Best Practices | Master production optimization techniques |
- 📊 Performance Monitoring and Metrics Collection
- 🚨 AI-Powered Incident Detection and Response
- 🔄 Continuous Improvement and Optimization Strategies
- 🚀 Production Deployment and Scaling Considerations
🎯 Goal: Apply all concepts in real-world scenarios
🎯 Objective | 📖 Description |
---|---|
🌍 Real Scenarios | Apply AI techniques to real-world development challenges |
🔄 End-to-End | Complete comprehensive implementation exercises |
💻 Multi-Language | Practice with Java and .NET examples |
💪 Confidence | Build expertise in AI-assisted problem solving |
- 🌍 Real-World Optimization Scenarios
- 🔄 End-to-End Implementation Exercises
- 💻 Multi-Language Practical Examples (Java and .NET)
- 📁 Reference:
/resources/common/templates/DatabaseConnection.java
- Java example - 📁 Reference:
/resources/common/templates/DatabaseConnection.cs
- C# example - 📁 Reference:
/resources/common/templates/application.properties
- Java configuration - 📁 Reference:
/resources/common/templates/appsettings.json
- .NET configuration
- 📁 Reference:
- 🧠 Problem-Solving with AI Assistance
📁 Automation Resources: Before starting, explore the automation tools available in
/resources/
to accelerate your setup process.
🛠️ Script | 🎯 Purpose | 💻 Command |
---|---|---|
🏗️ Azure Setup | Complete infrastructure setup | bash resources/common/setup/setup-azure-infrastructure.sh |
✅ Environment Validation | Verify all prerequisites | bash resources/common/setup/validate-setup.sh |
🧹 Cleanup | Remove test infrastructure | bash resources/common/setup/cleanup-azure-infrastructure.sh |
By completing these workshops, you will:
🎯 Skill | 📖 Description |
---|---|
🤖 AI Assistance | Understand how AI transforms software development |
⚡ GitHub Copilot | Set up and use GitHub Copilot for faster, better code |
📈 Code Optimization | Optimize existing code for performance and security |
🏗️ Modern Practices | Implement modern development practices with AI assistance |
💪 Confidence | Build confidence using AI tools for real-world projects |
📚 Phase | ⏱️ Duration | 🎯 Focus |
---|---|---|
🛠️ Preparation | 30-45 minutes | Setup and prerequisites |
🌱 Basic Workshop | 90 minutes | Core concepts and basics |
🔧 Intermediate Workshop | 2 hours | Advanced features (optional) |
⚡ Advanced Workshop | 3 hours | Enterprise solutions (optional) |
⏱️ Time Required: 5 minutes
Step | 🎯 Action | 📖 Details |
---|---|---|
1 | 🌐 Open Browser | Chrome, Firefox, Safari, or Edge |
2 | 🔗 Navigate to GitHub | Type github.com and press Enter |
3 | ✅ Click "Sign up" | Green button in top-right corner |
4 | 📝 Fill Information | Email, password, username |
5 | 🤖 Verify Human | Complete puzzle/captcha |
6 | 🎉 Create Account | Click "Create account" |
7 | 📧 Check Email | Look for GitHub verification email |
8 | ✅ Verify Email | Click verification link |
# GitHub Account Setup
Email Address: your-work-or-personal@email.com
Password: minimum-8-characters-strong-password
Username: professional-username-for-work
Verification: complete-captcha-puzzle
✅ Checkpoint: You should now be logged into GitHub and see your profile page
⏱️ Time Required: 5 minutes
Step | 🎯 Action | 📖 Details |
---|---|---|
1 | 🔗 Visit Copilot | Go to github.com/features/copilot |
2 | 🆓 Start Trial | Click "Start free trial" (blue button) |
3 | 👤 Choose Plan | Select "Individual" plan |
4 | 📋 Review Terms | Read and accept terms |
5 | ✅ Get Access | Click "Get access to GitHub Copilot" |
6 | 📧 Verify Email | Check email if verification required |
✅ Checkpoint: You should see "GitHub Copilot is now active" message
💡 Important: Trial lasts 30 days. After that, it's $10/month for individual use.
⏱️ Time Required: 10 minutes
# Method 1: Download from website
# 1. Go to: code.visualstudio.com
# 2. Click "Download for Windows"
# 3. Run the downloaded .exe file
# 4. Follow installer with these IMPORTANT settings:
# ✅ Accept license agreement
# ✅ Choose installation location (default is fine)
# ✅ CHECK "Add to PATH" option (IMPORTANT!)
# ✅ CHECK "Create desktop icon"
# ✅ Click "Install"
# Method 2: Using Package Manager (Advanced)
winget install Microsoft.VisualStudioCode
# Method 1: Download from website
# 1. Go to: code.visualstudio.com
# 2. Click "Download for Mac"
# 3. Open downloaded .zip file
# 4. Drag Visual Studio Code to Applications folder
# 5. Open VS Code from Applications
# Method 2: Using Homebrew
brew install --cask visual-studio-code
# Add Microsoft repository and install VS Code
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /etc/apt/trusted.gpg.d/
sudo sh -c 'echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/trusted.gpg.d/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'
# Update package index and install
sudo apt update
sudo apt install code
✅ Checkpoint: VS Code should open and show a Welcome screen
⏱️ Time Required: 5 minutes
Step | 🎯 Action | 📖 Details |
---|---|---|
1 | 🧩 Open Extensions | Click Extensions icon (4 squares) or Ctrl+Shift+X |
2 | 🔍 Search Copilot | Type: GitHub Copilot |
3 | 📦 Install Main | Find "GitHub Copilot" by GitHub → Install |
4 | 💬 Install Chat | Search and install "GitHub Copilot Chat" |
5 | 🔐 Sign In | Click "Sign in to GitHub" popup |
6 | 🌐 Authorize | Browser opens → Click "Authorize Visual-Studio-Code" |
7 | ✅ Verify | Return to VS Code → See "GitHub Copilot is ready" |
# Essential GitHub Copilot Extensions
Primary Extension:
Name: "GitHub Copilot"
Publisher: GitHub
Description: AI pair programmer
Chat Extension:
Name: "GitHub Copilot Chat"
Publisher: GitHub
Description: Conversational AI assistant
# Verification
Status Bar: Look for GitHub Copilot icon (bottom right)
Status: Should show "Ready" when working
✅ Checkpoint: GitHub Copilot icon appears in VS Code status bar (bottom right)
Choose either Java OR .NET (C#) for the basic workshop
⏱️ Time Required: 15 minutes
# Method 1: Download from Adoptium (Recommended)
# 1. Go to: adoptium.net
# 2. Click "Latest LTS Release" (Java 17 or 21)
# 3. Download .msi file for Windows
# 4. Run installer with these settings:
# ✅ Accept defaults
# ✅ CHECK "Set JAVA_HOME variable" (IMPORTANT!)
# ✅ CHECK "Add to PATH" (IMPORTANT!)
# Install Maven (Build Tool)
# 1. Go to: maven.apache.org/download.cgi
# 2. Download "Binary zip archive"
# 3. Extract to C:\maven
# 4. Add C:\maven\bin to PATH:
# - Search "Environment Variables" in Windows
# - Click "Environment Variables"
# - Find "Path" in System Variables
# - Click "Edit" → "New" → Add "C:\maven\bin"
# - Click OK on all dialogs
# Method 2: Using Package Manager
winget install EclipseAdoptium.Temurin.17.JDK
winget install Apache.Maven
# Install Homebrew first (if you don't have it)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# Install Java and Maven
brew install openjdk@17
brew install maven
# Add Java to your PATH
echo 'export PATH="/usr/local/opt/openjdk@17/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
# For Intel Macs, use:
echo 'export PATH="/usr/local/opt/openjdk@17/bin:$PATH"' >> ~/.zshrc
# For Apple Silicon Macs, use:
echo 'export PATH="/opt/homebrew/opt/openjdk@17/bin:$PATH"' >> ~/.zshrc
# Ubuntu/Debian
sudo apt update
sudo apt install openjdk-17-jdk maven
# CentOS/RHEL/Fedora
sudo dnf install java-17-openjdk-devel maven
# Arch Linux
sudo pacman -S jdk17-openjdk maven
# Check Java version
java -version
# Expected output: openjdk version "17.x.x" or similar
# Check Maven version
mvn -version
# Expected output: Apache Maven 3.x.x
# Check JAVA_HOME (important for development)
echo $JAVA_HOME # Linux/Mac
echo %JAVA_HOME% # Windows
⏱️ Time Required: 10 minutes
# Method 1: Download from Microsoft (Recommended)
# 1. Go to: dotnet.microsoft.com/download
# 2. Click "Download .NET" (latest version)
# 3. Run the installer
# 4. Follow installer (accept all defaults)
# Method 2: Using Package Manager
winget install Microsoft.DotNet.SDK.8
# Method 1: Using Homebrew (Recommended)
brew install dotnet
# Method 2: Download installer
# Go to: dotnet.microsoft.com/download
# Download .pkg file and run installer
# Ubuntu/Debian
wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
sudo apt-get update
sudo apt-get install -y dotnet-sdk-8.0
# CentOS/RHEL
sudo dnf install dotnet-sdk-8.0
# Arch Linux
sudo pacman -S dotnet-sdk
# Check .NET version
dotnet --version
# Expected output: 8.0.x or similar
# List installed SDKs
dotnet --list-sdks
# Create a test project (optional)
dotnet new console -n TestProject
cd TestProject
dotnet run
✅ Checkpoint: Either
java -version
ANDmvn -version
work (Java path) ORdotnet --version
works (.NET path)
⏱️ Time Required: 5 minutes
# Method 1: Download from Git website (Recommended)
# 1. Go to: git-scm.com
# 2. Click "Download for Windows"
# 3. Run installer with these IMPORTANT settings:
# ✅ Accept all defaults
# ✅ Choose "Git from command line and 3rd-party software"
# ✅ Choose "Use bundled OpenSSH"
# ✅ Choose "Use the OpenSSL library"
# ✅ Choose "Checkout Windows-style, commit Unix-style line endings"
# Method 2: Using Package Manager
winget install Git.Git
# Method 1: Using Homebrew (Recommended)
brew install git
# Method 2: Using Xcode Command Line Tools
xcode-select --install
# Method 3: Download from git-scm.com
# Ubuntu/Debian
sudo apt install git
# CentOS/RHEL/Fedora
sudo dnf install git
# Arch Linux
sudo pacman -S git
# Set your name and email (required for commits)
git config --global user.name "Your Full Name"
git config --global user.email "your.email@example.com"
# Optional: Set default branch name
git config --global init.defaultBranch main
# Optional: Set default editor
git config --global core.editor "code --wait" # Use VS Code as editor
# Verify configuration
git config --list
✅ Checkpoint:
git --version
shows a version number (2.x.x or higher)
🚀 Skip manual setup with our pre-built automation tools!
🎯 Category | 📄 File | 📋 Description | 💻 Usage |
---|---|---|---|
🏗️ Infrastructure | setup-azure-infrastructure.sh |
Complete Azure setup | bash resources/setup-azure-infrastructure.sh |
🪟 Windows Setup | setup-azure-infrastructure.ps1 |
PowerShell automation | .\resources\setup-azure-infrastructure.ps1 |
✅ Validation | validate-setup.sh |
Environment checker | bash resources/validate-setup.sh |
🔄 CI/CD Pipeline | azure-devops-pipeline.yml |
Azure DevOps template | Copy to your repository |
⚙️ GitHub Actions | github-actions-workflow.yml |
GitHub workflow | Copy to .github/workflows/ |
☕ Java Example | DatabaseConnection.java |
Production Java code | Reference implementation |
🔷 C# Example | DatabaseConnection.cs |
Production C# code | Reference implementation |
⚙️ Java Config | application.properties |
Spring Boot config | Copy to src/main/resources/ |
⚙️ .NET Config | appsettings.json |
.NET Core config | Copy to project root |
🤖 Multi-Agent | multi_agent_orchestrator.py |
AI orchestration | Advanced example |
🧹 Cleanup | cleanup-azure-infrastructure.sh |
Remove test resources | bash resources/cleanup-azure-infrastructure.sh |
# 1. Clone the workshop repository (if not already done)
git clone https://github.com/paulanunes85/Code-AI-Dev.git
cd Code-AI-Dev
# 2. Run the validation script to check prerequisites
bash resources/common/setup/validate-setup.sh
# 3. Set up Azure infrastructure (optional - for advanced workshops)
bash resources/common/setup/setup-azure-infrastructure.sh
# After running the setup script, the following Azure resources will be created:
# - Resource Group: aidevops-workshop-rg
# - SQL Server: aidevops-sql-server-[timestamp]
# - SQL Database: aidevops-workshop-db
# - Application Insights: aidevops-appinsights
# - AI Services: aidevops-ai-services
# - Storage Account: aidevopsstorage[timestamp]
# - Key Vault: aidevops-kv-[timestamp]
# Visual overview of created resources:
# 
# 4. Source the configuration file (if Azure setup was run)
# source resources/common/setup/workshop-config.env
# 5. Copy configuration templates to your project
cp resources/common/templates/application.properties your-java-project/src/main/resources/
cp resources/common/templates/appsettings.json your-dotnet-project/
# 6. Set up CI/CD pipelines
cp resources/intermediate/module5-cicd/azure-devops-pipeline.yml your-project/
cp resources/intermediate/module5-cicd/github-actions-workflow.yml your-project/.github/workflows/
💡 Pro Tip: All scripts include detailed comments and error handling. Review them to understand the automation process!
📍 Current Step | ⬅️ Previous | ➡️ Next |
---|---|---|
🛠️ Pre-Workshop Preparation | 🏠 Table of Contents | 🌱 Basic Workshop |
🎯 Complete AI development fundamentals in 90 minutes
The Basic Workshop consists of three core modules that build upon each other:
📚 Module | ⏱️ Duration | 🎯 Focus | 🏆 Outcome |
---|---|---|---|
Module 1: First AI Code | 30 minutes | AI-assisted coding basics | Working Calculator with AI |
Module 2: Optimization | 30 minutes | Performance improvements | 10x faster string operations |
Module 3: Security | 30 minutes | Security best practices | SQL injection prevention |
🎯 Goal: Transform from traditional development to AI-assisted workflows
graph LR
A[📝 Traditional<br/>100% Manual] --> B[🤖 AI-Assisted<br/>70% Manual, 30% AI]
B --> C[🚀 AI-First<br/>40% Oversight, 60% AI]
style A fill:#ffebee
style B fill:#fff3e0
style C fill:#e8f5e8
📊 Development Era | 👩💻 Developer Role | 🤖 AI Role | ⚡ Productivity Gain |
---|---|---|---|
📝 Traditional | Write every line manually | None | Baseline |
🤖 AI-Assisted | Guide AI suggestions | Code completion | 2-3x faster |
🚀 AI-First | Design and review | Code generation & optimization | 5-10x faster |
📊 Research shows developers spend their time on:
pie title Developer Time Distribution
"Non-coding tasks" : 60
"Fixing existing code" : 30
"Writing new code" : 10
📊 Activity | ⏱️ Time Spent | 📖 Examples |
---|---|---|
📋 Non-coding tasks | 60% | Planning, meetings, research, documentation |
🔧 Existing code | 30% | Bug fixes, refactoring, maintenance |
✨ New code | 10% | Actually writing new features |
🎯 Agentic DevOps helps optimize ALL three areas!
🔧 Tool | 📖 Description | 🎯 Primary Use |
---|---|---|
🤖 GitHub Copilot | AI pair programmer | Code completion and generation |
💬 GitHub Copilot Chat | Conversational AI assistant | Code explanation and debugging |
💻 Visual Studio Code | Development environment | Primary coding interface |
👨🏫 Workshop Facilitator Note:
- Participants WILL get different code suggestions - this is expected!
- Prepare to explain AI variability (it's a feature, not a bug)
- Emphasize that different implementations are learning opportunities
- Have the reference implementation ready to share if needed
- Encourage participants to share their variations with the group
⏱️ Time Required: 10 minutes
- Find VS Code on your computer:
- Windows: Click Start menu → type "Visual Studio Code" → Click to open
- Mac: Open Finder → Applications → Visual Studio Code
- Linux: Open terminal → type
code
and press Enter
- Wait for VS Code to fully load (you'll see the Welcome tab)
- Click
File
in the top menu - Select
New File
from the dropdown- Alternative: Press
Ctrl+N
(Windows/Linux) orCmd+N
(Mac)
- Alternative: Press
- You should see a new empty tab labeled "Untitled-1"
- Click
File
→Save As...
- Alternative: Press
Ctrl+S
(Windows/Linux) orCmd+S
(Mac)
- Alternative: Press
- Choose a location:
- Create a new folder called
workshop
on your Desktop - Navigate to: Desktop → workshop
- Create a new folder called
- Name your file:
- For Java: Type
Calculator.java
(IMPORTANT: Must end with.java
) - For C#: Type
Calculator.cs
(IMPORTANT: Must end with.cs
)
- For Java: Type
- Click the
Save
button
- Look at the bottom-right corner of VS Code
- Find the GitHub Copilot icon (looks like this: </>)
- Check the status:
- ✅ If it shows "GitHub Copilot" → You're ready!
- ❌ If it shows an error → Click it and sign in
- ❌ If you don't see it → Install the extension first
IMPORTANT: Type this comment EXACTLY as shown (copy-paste is OK):
- Click at the beginning of line 1 in your empty file
- Type this comment EXACTLY (or copy-paste it):
// Create a simple calculator class with add, subtract, multiply, and divide methods
- Press
Enter
twice to create a blank line - Wait 2-3 seconds - You should see gray text appear!
- Look for gray text (this is GitHub Copilot's suggestion)
- Read what it suggests - it should show a class definition
- To accept: Press the
Tab
key - To reject: Press
Esc
key or just keep typing
After accepting the suggestion, your code should look similar to this:
// Create a simple calculator class with add, subtract, multiply, and divide methods
public class Calculator {
// Addition method
public double add(double a, double b) {
return a + b;
}
// Subtraction method
public double subtract(double a, double b) {
return a - b;
}
// Multiplication method
public double multiply(double a, double b) {
return a * b;
}
// Division method with zero check
public double divide(double a, double b) {
if (b == 0) {
throw new IllegalArgumentException("Cannot divide by zero");
}
return a / b;
}
// Main method for testing
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("5 + 3 = " + calc.add(5, 3));
System.out.println("5 - 3 = " + calc.subtract(5, 3));
System.out.println("5 * 3 = " + calc.multiply(5, 3));
System.out.println("5 / 3 = " + calc.divide(5, 3));
}
}
- After accepting the class definition, Copilot will suggest the first method
- Keep pressing
Tab
to accept each suggestion - Continue until you have all 4 methods (add, subtract, multiply, divide)
- If suggestions stop, press
Enter
and wait 2-3 seconds
- Save the file: Press
Ctrl+S
(Windows/Linux) orCmd+S
(Mac) - Open terminal in VS Code:
- Click
Terminal
→New Terminal
in the menu - Or press
Ctrl+`
(backtick key)
- Click
- Compile and run:
javac Calculator.java java Calculator
- Expected output:
5 + 3 = 8.0 5 - 3 = 2.0 5 * 3 = 15.0 5 / 3 = 1.6666666666666667
- Click at the beginning of line 1 in your empty file
- Type this comment EXACTLY (or copy-paste it):
// Create a simple calculator class with add, subtract, multiply, and divide methods
- Press
Enter
twice to create a blank line - Wait 2-3 seconds - You should see gray text appear!
- Look for gray text (this is GitHub Copilot's suggestion)
- Read what it suggests - it should show
using System;
and a class definition - To accept: Press the
Tab
key - To reject: Press
Esc
key or just keep typing
After accepting the suggestion, your code should look similar to this:
// Create a simple calculator class with add, subtract, multiply, and divide methods
using System;
public class Calculator
{
// Addition method
public double Add(double a, double b)
{
return a + b;
}
// Subtraction method
public double Subtract(double a, double b)
{
return a - b;
}
// Multiplication method
public double Multiply(double a, double b)
{
return a * b;
}
// Division method with zero check
public double Divide(double a, double b)
{
if (b == 0)
{
throw new ArgumentException("Cannot divide by zero");
}
return a / b;
}
// Main method for testing
static void Main(string[] args)
{
Calculator calc = new Calculator();
Console.WriteLine($"5 + 3 = {calc.Add(5, 3)}");
Console.WriteLine($"5 - 3 = {calc.Subtract(5, 3)}");
Console.WriteLine($"5 * 3 = {calc.Multiply(5, 3)}");
Console.WriteLine($"5 / 3 = {calc.Divide(5, 3)}");
}
}
- After accepting the class definition, Copilot will suggest the first method
- Keep pressing
Tab
to accept each suggestion - Continue until you have all 4 methods (Add, Subtract, Multiply, Divide)
- If suggestions stop, press
Enter
and wait 2-3 seconds
- Save the file: Press
Ctrl+S
(Windows/Linux) orCmd+S
(Mac) - Open terminal in VS Code:
- Click
Terminal
→New Terminal
in the menu - Or press
Ctrl+`
(backtick key)
- Click
- Run the code:
dotnet run
- Note: If you get an error, you may need to create a project first:
dotnet new console -n Calculator # Copy your Calculator.cs file into the Calculator folder cd Calculator dotnet run
- Note: If you get an error, you may need to create a project first:
- Expected output:
5 + 3 = 8 5 - 3 = 2 5 * 3 = 15 5 / 3 = 1.6666666666666667
What to check:
- Bottom-right corner - Is the Copilot icon there?
- Click the Copilot icon - Does it say "Ready" or show an error?
- Internet connection - Are you connected?
Solution:
- If no icon: Install GitHub Copilot extension
- If error: Click icon → Sign in to GitHub
- If offline: Connect to internet and restart VS Code
What to do:
- Delete everything and start over
- Copy-paste the exact comment from the workshop
- Wait longer (sometimes it takes 5-10 seconds)
- Press Enter after the comment and try again
For Java:
# Error: javac not found
# Solution: Install Java JDK first
# Error: class not found
# Solution: Make sure filename matches class name exactly
For C#:
# Error: dotnet not found
# Solution: Install .NET SDK first
# Error: No project file
# Solution: Create a console project first (see Step 8)
✅ Checkpoint: You should see AI-generated code for a Calculator class
✅ How to create and save files with correct extensions in VS Code ✅ How to write comments that trigger GitHub Copilot suggestions ✅ How to accept AI suggestions with Tab key ✅ How to compile and run Java/C# programs ✅ How to troubleshoot when AI suggestions don't appear
🎯 Critical Workshop Note: GitHub Copilot's suggestions can vary significantly!
🎯 Factor | 📖 Description | 💡 Impact |
---|---|---|
🤖 Model Version | Copilot updates its AI model regularly | Different versions = different suggestions |
📝 Context | Your file history and open files affect suggestions | More context = more tailored suggestions |
🌍 Training Data | Model trained on different code patterns over time | Newer models may suggest different patterns |
⚙️ Settings | IDE settings and Copilot configuration | Different settings = different behavior |
🔄 Randomness | AI models have inherent randomness | Same prompt can yield different results |
To ensure everyone gets similar results:
- 🎯 Use Exact Comments: Copy comments exactly as shown in the workshop
- 📋 Compare with Examples: Always compare your generated code with workshop examples
- 🔧 Manual Adjustments: Be prepared to manually adjust generated code
- 📚 Reference Code: Use provided code snippets as the "source of truth"
What You Might See:
- ✅ Similar structure but different variable names
- ✅ Different method order
- ✅ Additional or missing comments
- ✅ Different error handling approaches
- ✅ Various code formatting styles
What's Important:
- ✅ Core functionality (add, subtract, multiply, divide)
- ✅ Basic error handling (division by zero)
- ✅ Proper method signatures
- ✅ Working test/main method
💡 Pro Tip: If Copilot generates significantly different code, use it as a learning opportunity to understand different implementation approaches!
📚 Having questions about AI variability? Check our comprehensive Workshop FAQ for answers to:
- Why your code differs from others
- Whether different implementations are correct
- How to evaluate AI-generated code quality
- When to modify vs. keep AI suggestions
- And many more common concerns!
If GitHub Copilot generates very different code, use this reference implementation:
🔍 Click to see the expected Calculator implementation
Java Version:
public class Calculator {
public double add(double a, double b) {
return a + b;
}
public double subtract(double a, double b) {
return a - b;
}
public double multiply(double a, double b) {
return a * b;
}
public double divide(double a, double b) {
if (b == 0) {
throw new IllegalArgumentException("Cannot divide by zero");
}
return a / b;
}
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("5 + 3 = " + calc.add(5, 3));
System.out.println("5 - 3 = " + calc.subtract(5, 3));
System.out.println("5 * 3 = " + calc.multiply(5, 3));
System.out.println("5 / 3 = " + calc.divide(5, 3));
}
}
C# Version:
using System;
public class Calculator
{
public double Add(double a, double b)
{
return a + b;
}
public double Subtract(double a, double b)
{
return a - b;
}
public double Multiply(double a, double b)
{
return a * b;
}
public double Divide(double a, double b)
{
if (b == 0)
{
throw new ArgumentException("Cannot divide by zero");
}
return a / b;
}
static void Main(string[] args)
{
Calculator calc = new Calculator();
Console.WriteLine($"5 + 3 = {calc.Add(5, 3)}");
Console.WriteLine($"5 - 3 = {calc.Subtract(5, 3)}");
Console.WriteLine($"5 * 3 = {calc.Multiply(5, 3)}");
Console.WriteLine($"5 / 3 = {calc.Divide(5, 3)}");
}
}
⏱️ Time Required: 10 minutes
✅ Check | 📖 Question | 🎯 What to Look For |
---|---|---|
📋 Completeness | Does it have all four methods? | add, subtract, multiply, divide |
🔧 Method Signatures | Are the parameters reasonable? | double parameters, double return |
Does it handle edge cases? | Division by zero protection | |
🧪 Testing | Is there a main method? | Example usage or test code |
// Test the AI's understanding - Add this comment:
// Add a method to calculate percentage
/*
Expected AI suggestion:
*/
public double calculatePercentage(double value, double total) {
if (total == 0) {
throw new IllegalArgumentException("Total cannot be zero");
}
return (value / total) * 100;
}
// Test AI's attention to detail - Add this comment:
// TODO: Add input validation to prevent division by zero
/*
AI should recognize that division by zero is already handled
and might suggest additional validation like:
*/
public double divideWithValidation(double dividend, double divisor) {
// Input validation
if (Double.isNaN(dividend) || Double.isNaN(divisor)) {
throw new IllegalArgumentException("Input cannot be NaN");
}
if (Double.isInfinite(dividend) || Double.isInfinite(divisor)) {
throw new IllegalArgumentException("Input cannot be infinite");
}
if (divisor == 0) {
throw new IllegalArgumentException("Cannot divide by zero");
}
return dividend / divisor;
}
🎯 Practice | 📖 Description | ✅ Example |
---|---|---|
🎯 Be Specific | Detailed comments get better results | "Create a thread-safe calculator with exception handling" |
📋 Use TODO | AI understands TODO comments | // TODO: Add logging to all methods |
🔢 Include Examples | Show expected input/output | // Example: calculateTax(100, 0.15) should return 15 |
Specify requirements | // Must be compatible with Java 8+ |
🧠 Learning Point: AI understands context from comments and existing code. The more specific your comments, the better the suggestions.
📍 Current Step | ⬅️ Previous | ➡️ Next |
---|---|---|
🚀 Module 1: First Steps with AI Assistance | 🛠️ Pre-Workshop Preparation | ⚡ Module 2: Code Optimization |
⏱️ Time Required: 15 minutes
📊 Problem: String concatenation in loops is inefficient and can cause performance issues
- In VS Code, click
File
→New File
- Save immediately with the correct name:
- Press
Ctrl+S
(Windows/Linux) orCmd+S
(Mac) - For Java: Name it
StringExample.java
- For C#: Name it
StringExample.cs
- Save in the same
workshop
folder you created earlier
- Press
- Select and copy the ENTIRE code block below (use
Ctrl+A
thenCtrl+C
) - Paste into your new file (use
Ctrl+V
) - Save the file (
Ctrl+S
)
import java.util.List;
import java.util.Arrays;
public class StringExample {
public static void main(String[] args) {
// Create test data
List<String> names = Arrays.asList(
"Alice", "Bob", "Charlie", "David", "Eve",
"Frank", "Grace", "Henry", "Ivy", "Jack"
);
// INEFFICIENT: String concatenation in loop
System.out.println("Testing INEFFICIENT approach...");
long startTime = System.nanoTime();
String result = "";
for (String name : names) {
result = result + name + ", "; // Creates new String object each time!
}
long endTime = System.nanoTime();
System.out.println("Result: " + result);
System.out.println("Time taken: " + (endTime - startTime) + " nanoseconds");
// Now let's see the AI optimization suggestion...
}
}
using System;
using System.Collections.Generic;
using System.Diagnostics;
class StringExample
{
static void Main()
{
// Create test data
List<string> names = new List<string> {
"Alice", "Bob", "Charlie", "David", "Eve",
"Frank", "Grace", "Henry", "Ivy", "Jack"
};
// INEFFICIENT: String concatenation in loop
Console.WriteLine("Testing INEFFICIENT approach...");
Stopwatch stopwatch = Stopwatch.StartNew();
string result = "";
foreach (string name in names)
{
result = result + name + ", "; // Creates new string object each time!
}
stopwatch.Stop();
Console.WriteLine($"Result: {result}");
Console.WriteLine($"Time taken: {stopwatch.ElapsedTicks} ticks");
// Now let's see the AI optimization suggestion...
}
}
- Open terminal in VS Code:
- Click
Terminal
→New Terminal
- Or press
Ctrl+`
(backtick)
- Click
- Compile the code:
javac StringExample.java
- Run the code:
java StringExample
- Expected output:
Testing INEFFICIENT approach... Result: Alice, Bob, Charlie, David, Eve, Frank, Grace, Henry, Ivy, Jack, Time taken: [some number] nanoseconds
- Note the time - We'll compare this later!
- Open terminal in VS Code (
Ctrl+`
) - Run directly:
dotnet run
- Expected output: Similar to Java, showing names and timing
- Click and drag to select these specific lines:
- Java: Lines containing
result = result + name + ", ";
- C#: Lines containing
result = result + name + ", ";
- Java: Lines containing
- The selected text should be highlighted in blue
- Right-click on the selected (highlighted) code
- Look for "GitHub Copilot" in the menu
- Click "Explain this" or "Fix this"
- If you don't see these options, try pressing
Ctrl+I
(Windows/Linux) orCmd+I
(Mac)
- If you don't see these options, try pressing
- Click at the end of the line BEFORE the loop starts
- Press Enter to create a new line
- Type this comment exactly:
// Optimize this string concatenation for better performance
// Use StringBuilder for efficient string building
- Wait 2-3 seconds after typing the comment
- Look for gray text suggesting StringBuilder code
- Press Tab to accept the suggestion
- Continue pressing Tab until the optimization is complete
// OPTIMIZED: Using StringBuilder
System.out.println("Testing OPTIMIZED approach...");
startTime = System.nanoTime();
StringBuilder sb = new StringBuilder();
for (String name : names) {
sb.append(name).append(", ");
}
String optimizedResult = sb.toString();
endTime = System.nanoTime();
System.out.println("Result: " + optimizedResult);
System.out.println("Time taken: " + (endTime - startTime) + " nanoseconds");
// Performance comparison
System.out.println("\nPERFORMANCE ANALYSIS:");
System.out.println("String concatenation: Creates " + names.size() + " intermediate String objects");
System.out.println("StringBuilder: Uses internal buffer, much more efficient");
// OPTIMIZED: Using StringBuilder
Console.WriteLine("Testing OPTIMIZED approach...");
stopwatch.Restart();
StringBuilder sb = new StringBuilder();
foreach (string name in names)
{
sb.Append(name).Append(", ");
}
string optimizedResult = sb.ToString();
stopwatch.Stop();
Console.WriteLine($"Result: {optimizedResult}");
Console.WriteLine($"Time taken: {stopwatch.ElapsedTicks} ticks");
// Performance comparison
Console.WriteLine("\nPERFORMANCE ANALYSIS:");
Console.WriteLine($"String concatenation: Creates {names.Count} intermediate string objects");
Console.WriteLine("StringBuilder: Uses internal buffer, much more efficient");
🔧 Method | 🧠 Memory Usage | ⏱️ Time Complexity | 📈 Scalability |
---|---|---|---|
🐌 String Concatenation | O(n²) - each concat creates new object | O(n²) | Poor for large datasets |
🚀 StringBuilder | O(n) - internal buffer expansion | O(n) | Excellent for large datasets |
🧠 Learning Point: StringBuilder is much faster for multiple string concatenations because strings are immutable in both Java and C#.
- Save your file with both versions (
Ctrl+S
) - Run the code again:
- Java:
javac StringExample.java && java StringExample
- C#:
dotnet run
- Java:
- Compare the times:
Testing INEFFICIENT approach... Time taken: [LARGER NUMBER] nanoseconds Testing OPTIMIZED approach... Time taken: [SMALLER NUMBER] nanoseconds
- Calculate improvement: The optimized version should be 5-10x faster!
⏱️ Time Required: 10 minutes
- File → New File in VS Code
- Save as:
- Java:
StringPerformanceTest.java
- C#:
StringPerformanceTest.cs
- Java:
- Type this comment at the top of your new file:
// Create a comprehensive performance test that:
// 1. Tests string concatenation vs StringBuilder with different data sizes
// 2. Shows performance improvement percentages
// 3. Tests with 100, 1000, 5000, and 10000 items
- Wait for gray text to appear
- Press Tab to accept the complete test class
- Continue accepting until you have a full performance test
public class StringPerformanceComparison {
public static void main(String[] args) {
// Test different dataset sizes
int[] sizes = {100, 1000, 5000, 10000};
for (int size : sizes) {
System.out.println("\nTesting with " + size + " items:");
List<String> testData = generateTestData(size);
// Test string concatenation
long stringConcatTime = testStringConcatenation(testData);
// Test StringBuilder
long stringBuilderTime = testStringBuilder(testData);
// Performance analysis
double improvement = (double) stringConcatTime / stringBuilderTime;
System.out.printf("StringBuilder is %.2fx faster%n", improvement);
}
}
private static List<String> generateTestData(int size) {
List<String> data = new ArrayList<>();
for (int i = 0; i < size; i++) {
data.add("Item" + i);
}
return data;
}
private static long testStringConcatenation(List<String> data) {
long startTime = System.nanoTime();
String result = "";
for (String item : data) {
result += item + ", ";
}
long endTime = System.nanoTime();
System.out.println("String concatenation: " + (endTime - startTime) / 1_000_000 + " ms");
return endTime - startTime;
}
private static long testStringBuilder(List<String> data) {
long startTime = System.nanoTime();
StringBuilder sb = new StringBuilder();
for (String item : data) {
sb.append(item).append(", ");
}
String result = sb.toString();
long endTime = System.nanoTime();
System.out.println("StringBuilder: " + (endTime - startTime) / 1_000_000 + " ms");
return endTime - startTime;
}
}
📊 Dataset Size | 🐌 String Concat | 🚀 StringBuilder | ⚡ Improvement |
---|---|---|---|
100 items | ~5 ms | ~1 ms | ~5x faster |
1,000 items | ~150 ms | ~2 ms | ~75x faster |
5,000 items | ~3,500 ms | ~8 ms | ~440x faster |
10,000 items | ~14,000 ms | ~15 ms | ~930x faster |
✅ Checkpoint: You should see significant performance differences with larger datasets
✅ Why string concatenation in loops is inefficient ✅ How to use StringBuilder for better performance ✅ How to measure and compare code performance ✅ How to ask Copilot to optimize existing code ✅ Performance improvements can be 10x-1000x for large datasets
📍 Current Step | ⬅️ Previous | ➡️ Next |
---|---|---|
⚡ Module 2: Code Optimization with AI | 🚀 Module 1: First AI Code | 🔒 Module 3: Security |
⏱️ Time Required: 20 minutes
⚠️ Problem: Unsafe SQL queries can be exploited by attackers
- In VS Code, create a new file:
- Click
File
→New File
- Save immediately:
Ctrl+S
(Windows/Linux) orCmd+S
(Mac)
- Click
- Name your file:
- Java:
DatabaseExample.java
- C#:
DatabaseExample.cs
- Java:
- Save in your
workshop
folder
- Copy the ENTIRE code block below for your language
- Paste into your file
- Save the file
📁 Reference: Compare with the secure implementation in
/resources/common/templates/DatabaseConnection.java
import java.sql.*;
public class DatabaseExample {
// ❌ VULNERABLE: SQL Injection risk
public User findUser(String username) {
try {
Connection conn = DriverManager.getConnection(
"jdbc:h2:mem:testdb", "user", "password"
);
// DANGEROUS: Direct string concatenation in SQL
String query = "SELECT * FROM users WHERE username = '" + username + "'";
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(query);
if (rs.next()) {
return new User(rs.getString("username"), rs.getString("email"));
}
} catch (SQLException e) {
e.printStackTrace(); // Poor error handling
}
return null;
}
// Simple User class
static class User {
String username, email;
User(String username, String email) {
this.username = username;
this.email = email;
}
@Override
public String toString() {
return "User{username='" + username + "', email='" + email + "'}";
}
}
}
📁 Reference: Compare with the secure implementation in
/resources/common/templates/DatabaseConnection.cs
using System;
using System.Data.SqlClient;
class DatabaseExample
{
// ❌ VULNERABLE: SQL Injection risk
public User FindUser(string username)
{
try
{
using var connection = new SqlConnection(
"Server=.;Database=TestDB;Integrated Security=true"
);
connection.Open();
// DANGEROUS: Direct string interpolation in SQL
string query = $"SELECT * FROM users WHERE username = '{username}'";
using var command = new SqlCommand(query, connection);
using var reader = command.ExecuteReader();
if (reader.Read())
{
return new User(reader["username"].ToString(), reader["email"].ToString());
}
}
catch (Exception e)
{
Console.WriteLine($"Error: {e.Message}"); // Poor error handling
}
return null;
}
// Simple User class
public class User
{
public string Username { get; set; }
public string Email { get; set; }
public User(string username, string email)
{
Username = username;
Email = email;
}
public override string ToString()
{
return $"User{{Username='{Username}', Email='{Email}'}}";
}
}
}
- Click the chat icon in VS Code's sidebar (looks like a speech bubble)
- Or press
Ctrl+Shift+I
(Windows/Linux) orCmd+Shift+I
(Mac)
- Or press
- Make sure your DatabaseExample file is open and active
- Type this exact question in the chat:
Analyze the DatabaseExample.java file for security vulnerabilities.
Focus on SQL injection risks and show me exactly how an attacker could exploit this code.
- Press Enter and wait for the response
- Read carefully - Copilot will explain the SQL injection vulnerability
- Look at this line in your code:
String query = "SELECT * FROM users WHERE username = '" + username + "'";
- Imagine a user enters:
admin' OR '1'='1
- The query becomes:
SELECT * FROM users WHERE username = 'admin' OR '1'='1'
- Result: Returns ALL users because '1'='1' is always true!
🚨 CRITICAL SECURITY ISSUES FOUND:
🔴 Severity | 🚨 Vulnerability | 📖 Description | 🎯 Attack Example |
---|---|---|---|
🚨 CRITICAL | SQL Injection | Direct string concatenation | '; DROP TABLE users; -- |
🔴 HIGH | Information Disclosure | Stack traces exposed | Error messages reveal system info |
🟡 MEDIUM | No Input Validation | Accepts any input | Null, empty, or malicious strings |
🟡 MEDIUM | Hard-coded Credentials | Database connection info | Credentials in source code |
-- 🚨 Malicious input examples that would break the vulnerable code:
-- 1. 💣 Drop entire table
username = "'; DROP TABLE users; --"
-- Resulting query: SELECT * FROM users WHERE username = ''; DROP TABLE users; --'
-- 2. 🕵️ Access all users
username = "' OR '1'='1"
-- Resulting query: SELECT * FROM users WHERE username = '' OR '1'='1'
-- 3. 📊 Extract sensitive data
username = "' UNION SELECT password, credit_card FROM sensitive_data --"
-- Resulting query: SELECT * FROM users WHERE username = '' UNION SELECT password, credit_card FROM sensitive_data --'
- In Copilot Chat, type:
Fix the SQL injection vulnerability in my DatabaseExample.java file.
Use parameterized queries and add input validation.
Show me the complete secure version.
- Press Enter and wait for the response
- Create a new file:
SecureDatabaseExample.java
orSecureDatabaseExample.cs
- Copy the secure code from Copilot's response
- Or use the reference implementation below
✅ Parameterized Queries: Uses ?
placeholders instead of string concatenation
✅ Input Validation: Checks for null, empty, and dangerous characters
✅ Error Handling: Doesn't expose system details in errors
✅ Prepared Statements: Prevents SQL injection completely
import java.sql.*;
import java.util.logging.Logger;
import java.util.logging.Level;
public class SecureDatabaseExample {
private static final Logger LOGGER = Logger.getLogger(SecureDatabaseExample.class.getName());
// SECURE: Using parameterized queries
public User findUser(String username) {
// Input validation
if (username == null || username.trim().isEmpty()) {
throw new IllegalArgumentException("Username cannot be null or empty");
}
// Additional validation
if (username.length() > 50) {
throw new IllegalArgumentException("Username too long");
}
// Blacklist dangerous characters
if (username.contains("'") || username.contains(";") || username.contains("--")) {
throw new IllegalArgumentException("Username contains invalid characters");
}
try (Connection conn = DriverManager.getConnection(
"jdbc:h2:mem:testdb", "user", "password");
// SECURE: Parameterized query prevents SQL injection
PreparedStatement stmt = conn.prepareStatement(
"SELECT username, email FROM users WHERE username = ?")) {
stmt.setString(1, username); // Safe parameter binding
try (ResultSet rs = stmt.executeQuery()) {
if (rs.next()) {
return new User(rs.getString("username"), rs.getString("email"));
}
}
} catch (SQLException e) {
// Secure error handling - don't expose details
LOGGER.log(Level.SEVERE, "Database error occurred", e);
throw new RuntimeException("Database operation failed");
}
return null;
}
// Additional security method
public boolean isValidUsername(String username) {
return username != null &&
!username.trim().isEmpty() &&
username.length() <= 50 &&
username.matches("^[a-zA-Z0-9_]+$"); // Only alphanumeric and underscore
}
}
using System;
using System.Data.SqlClient;
using System.Text.RegularExpressions;
using Microsoft.Extensions.Logging;
class SecureDatabaseExample
{
private readonly ILogger<SecureDatabaseExample> _logger;
public SecureDatabaseExample(ILogger<SecureDatabaseExample> logger)
{
_logger = logger;
}
// SECURE: Using parameterized queries
public User FindUser(string username)
{
// Input validation
if (string.IsNullOrWhiteSpace(username))
{
throw new ArgumentException("Username cannot be null or empty");
}
// Additional validation
if (username.Length > 50)
{
throw new ArgumentException("Username too long");
}
// Pattern validation
if (!IsValidUsername(username))
{
throw new ArgumentException("Username contains invalid characters");
}
try
{
using var connection = new SqlConnection(
"Server=.;Database=TestDB;Integrated Security=true");
connection.Open();
// SECURE: Parameterized query prevents SQL injection
string query = "SELECT username, email FROM users WHERE username = @username";
using var command = new SqlCommand(query, connection);
command.Parameters.AddWithValue("@username", username); // Safe parameter binding
using var reader = command.ExecuteReader();
if (reader.Read())
{
return new User(reader["username"].ToString(), reader["email"].ToString());
}
}
catch (SqlException e)
{
// Secure error handling - don't expose details
_logger.LogError(e, "Database error occurred");
throw new InvalidOperationException("Database operation failed");
}
return null;
}
// Username validation method
private bool IsValidUsername(string username)
{
return !string.IsNullOrWhiteSpace(username) &&
username.Length <= 50 &&
Regex.IsMatch(username, @"^[a-zA-Z0-9_]+$"); // Only alphanumeric and underscore
}
}
🔧 Security Measure | ❌ Before | ✅ After |
---|---|---|
🔍 SQL Injection | Direct concatenation | Parameterized queries |
📝 Input Validation | None | Length, format, character validation |
🚨 Error Handling | Exposes stack traces | Logs securely, generic user messages |
📊 Data Access | SELECT * (all columns) | SELECT specific columns only |
🔐 Connection Security | Hard-coded credentials | Configuration-based |
- Create new file:
SecurityTest.java
orSecurityTest.cs
- Add this comment at the top:
// Create a test class that demonstrates:
// 1. SQL injection attempts that fail with secure code
// 2. Valid inputs that work correctly
// 3. Input validation in action
- Accept Copilot's suggestions for a complete test
- Compile and run your test
- Try these malicious inputs:
admin' OR '1'='1
'; DROP TABLE users; --
' UNION SELECT * FROM sensitive_data --
- Verify that the secure version rejects these attacks!
⏱️ Time Required: 5 minutes
- Create:
InputValidator.java
orInputValidator.cs
- Type this comment:
// Create a comprehensive input validator that:
// 1. Checks for null and empty strings
// 2. Validates length (max 50 characters)
// 3. Only allows letters, numbers, dots, hyphens, and underscores
// 4. Detects common SQL injection patterns
// 5. Provides clear error messages
- Wait for Copilot suggestions
- Press Tab to accept
- Read each validation method to understand what it does
public class InputValidator {
private static final int MAX_USERNAME_LENGTH = 50;
private static final String VALID_USERNAME_PATTERN = "^[a-zA-Z0-9_.-]+$";
// SQL injection patterns to detect
private static final String[] SQL_INJECTION_PATTERNS = {
"'", "\"", ";", "--", "/*", "*/", "xp_", "sp_",
"union", "select", "insert", "delete", "update",
"drop", "create", "alter", "exec", "execute"
};
public static void validateUsername(String username) {
// Null and empty validation
if (username == null || username.trim().isEmpty()) {
throw new IllegalArgumentException("Username cannot be null or empty");
}
// Length validation
if (username.length() > MAX_USERNAME_LENGTH) {
throw new IllegalArgumentException("Username exceeds maximum length of " + MAX_USERNAME_LENGTH);
}
// Pattern validation
if (!username.matches(VALID_USERNAME_PATTERN)) {
throw new IllegalArgumentException("Username contains invalid characters. Only letters, numbers, dots, hyphens, and underscores allowed.");
}
// SQL injection detection
String lowercaseUsername = username.toLowerCase();
for (String pattern : SQL_INJECTION_PATTERNS) {
if (lowercaseUsername.contains(pattern.toLowerCase())) {
throw new SecurityException("Username contains potentially dangerous characters");
}
}
}
// Test method
public static void main(String[] args) {
String[] testCases = {
"valid_user123", // Valid
"user.name-test", // Valid
"", // ❌ Empty
null, // ❌ Null
"user'; DROP TABLE", // ❌ SQL injection
"very_long_username_that_exceeds_the_maximum_allowed_length_limit", // ❌ Too long
"user@domain.com", // Invalid character (@)
};
for (String testCase : testCases) {
try {
validateUsername(testCase);
System.out.println("Valid: " + testCase);
} catch (Exception e) {
System.out.println("Invalid: " + testCase + " - " + e.getMessage());
}
}
}
}
🛡️ Security Learning Points:
- ✅ Never concatenate user input directly into SQL queries
- ✅ Always validate input before processing
- ✅ Use parameterized queries or prepared statements
- ✅ Log errors securely without exposing sensitive information
- ✅ AI can help identify and fix common security vulnerabilities
✅ Checkpoint: Your code now uses parameterized queries and comprehensive input validation instead of vulnerable string concatenation
✅ How SQL injection attacks work and why they're dangerous ✅ How to use parameterized queries to prevent SQL injection ✅ Importance of input validation and sanitization ✅ How to use Copilot Chat for security analysis ✅ Best practices for secure database access
📍 Current Step | ⬅️ Previous | ➡️ Next |
---|---|---|
🔒 Module 3: Security Improvement with AI | ⚡ Module 2: Optimization | 🔧 Intermediate Workshop |
🎯 Advanced AI development techniques for experienced developers
The Intermediate Workshop extends the basic concepts with advanced features:
📚 Topic | ⏱️ Duration | 🎯 Focus | 🏆 Skills Gained |
---|---|---|---|
Advanced Copilot Features | 30 minutes | Chat, workspace commands | Multi-file AI assistance |
CI/CD Integration | 30 minutes | Pipeline automation | AI-powered DevOps |
Custom AI Workflows | 30 minutes | Workflow design | Automated code reviews |
Multi-Agent Systems | 30 minutes | Agent orchestration | Complex automation |
- Create a new folder on your Desktop called
advanced-workshop
- Open VS Code
- Open the folder: File → Open Folder → Select
advanced-workshop
- Create project structure:
advanced-workshop/ ├── src/ │ ├── models/ │ ├── services/ │ └── utils/ └── tests/
- Create a file:
src/models/User.java
orUser.cs
- Paste this legacy code:
public class User { public String n; // name public int a; // age public String e; // email public User(String n, int a, String e) { this.n = n; this.a = a; this.e = e; } }
- Open Copilot Chat (
Ctrl+Shift+I
orCmd+Shift+I
) - Type: "Refactor this User class with proper naming, validation, and builder pattern"
- Apply the suggestions by clicking "Insert at Cursor"
- Create multiple related files:
src/models/Product.java
src/services/UserService.java
src/services/ProductService.java
- In Copilot Chat, type:
@workspace Create interfaces for all services in the services folder
- Review and apply the generated interfaces
- Select all files in the services folder
- Ask Copilot:
Add comprehensive error handling and logging to all selected service files
- Review changes before applying
✅ Checkpoint: You now have a properly structured project with interfaces and error handling
- In your project root, create folders:
mkdir -p .github/workflows
- Create file:
.github/workflows/ci.yml
- Type this comment:
# Create a comprehensive CI/CD pipeline that: # 1. Runs on push to main and pull requests # 2. Sets up Java/C# environment # 3. Runs tests with coverage # 4. Performs security scanning # 5. Deploys to staging if tests pass
- Accept Copilot's suggestions for complete workflow
- In the same workflow file, add:
# Add a job that uses AI to review code changes and comment on PRs
- Let Copilot generate the AI review job
- Save the file
- Create file:
azure-pipelines.yml
- Copy template:
cp resources/intermediate/module5-cicd/azure-devops-pipeline.yml ./azure-pipelines.yml
- Ask Copilot: "Customize this pipeline for my Java/C# project with AI-powered testing"
- Install act (GitHub Actions local runner):
# Mac brew install act # Windows choco install act-cli
- Run locally:
act -j build
- Fix any issues with Copilot's help
✅ Checkpoint: You have working CI/CD pipelines with AI integration
- Create file:
scripts/ai-code-review.js
- Type:
// Create an automated code review script that: // 1. Analyzes code complexity // 2. Checks for security vulnerabilities // 3. Suggests performance improvements // 4. Generates a markdown report
- Accept Copilot's implementation
- Create:
scripts/generate-docs.py
- Add comment:
# Build a documentation generator that: # 1. Scans all source files # 2. Extracts comments and function signatures # 3. Generates markdown documentation # 4. Creates API reference
- Let Copilot build the complete script
- Create:
.pre-commit-config.yaml
- Ask Copilot:
Create pre-commit hooks for: - Code formatting - Security scanning - Test execution - AI-powered code review
- Install pre-commit:
pip install pre-commit pre-commit install
- Make a code change
- Attempt to commit:
git add . git commit -m "Test AI workflows"
- Watch the AI workflows run automatically
✅ Checkpoint: Automated AI workflows are running on every commit
- Open:
resources/intermediate/module7-multi-agent/multi_agent_orchestrator.py
- In Copilot Chat, ask:
Explain how this multi-agent orchestrator works and create a diagram
- Study the architecture before implementing
- Create file:
agents/code_optimizer_agent.py
- Type:
# Create an AI agent that: # 1. Monitors code performance metrics # 2. Identifies optimization opportunities # 3. Generates optimization suggestions # 4. Can work with other agents
- Build on Copilot's suggestions
- Create:
agents/agent_communication.py
- Ask Copilot:
Implement a message passing system for agents to communicate Include: message queues, event handling, and state management
- Review and understand the implementation
- Create:
orchestrate_agents.py
- Implement:
# Create an orchestrator that coordinates: # 1. Code review agent # 2. Security scanning agent # 3. Performance optimization agent # 4. Documentation generation agent
- Test the system:
python orchestrate_agents.py --target ./src
✅ Checkpoint: You have a working multi-agent system for code optimization
✅ Advanced Copilot Chat features for multi-file operations ✅ Creating and customizing CI/CD pipelines with AI ✅ Building custom AI-powered development workflows ✅ Implementing multi-agent systems for complex automation ✅ Orchestrating AI agents for collaborative tasks
🎯 Enterprise-grade AI development patterns and practices
The Advanced Track focuses on production-ready implementations:
📚 Module | ⏱️ Duration | 🎯 Focus | 🏆 Deliverable |
---|---|---|---|
Enterprise Architecture | 45 minutes | Scalable AI patterns | Architecture diagrams |
Security & Compliance | 45 minutes | Enterprise security | Security framework |
Performance at Scale | 30 minutes | High-performance systems | Optimization strategies |
Governance Framework | 30 minutes | AI governance | Policy templates |
- Create project folder:
enterprise-ai-system
- Open in VS Code
- Create:
architecture/microservices-design.md
- In Copilot Chat, type:
Design a microservices architecture for an e-commerce platform with: - User service - Product catalog service - Order service - Payment service - AI recommendation service Include API gateways, service mesh, and event bus
- Save the generated architecture
- Create service template:
templates/microservice-template/
- Add this structure:
microservice-template/ ├── src/ │ ├── api/ │ ├── domain/ │ ├── infrastructure/ │ └── application/ ├── tests/ ├── Dockerfile └── docker-compose.yml
- In each folder, ask Copilot:
Generate a complete microservice template following DDD principles
- Create:
infrastructure/service-discovery.yaml
- Type:
# Create a Kubernetes configuration for: # 1. Service discovery with Consul # 2. AI-powered load balancing # 3. Automatic failover # 4. Health monitoring
- Review and understand the configuration
- Create:
infrastructure/event-bus-config.yaml
- Ask Copilot:
Create an event-driven architecture using: - Apache Kafka for message streaming - AI-powered event routing - Dead letter queue handling - Event sourcing patterns
- Test with:
docker-compose -f infrastructure/docker-compose.yml up
✅ Checkpoint: You have a complete microservices architecture with AI integration
- Create:
security/security-scan-pipeline.yml
- Add this comment:
# Create a comprehensive security pipeline that: # 1. Scans for OWASP Top 10 vulnerabilities # 2. Checks dependencies for CVEs # 3. Performs SAST and DAST analysis # 4. Generates security reports # 5. Blocks deployment if critical issues found
- Let Copilot generate the complete pipeline
- Create:
compliance/compliance-checker.py
- Type:
# Build a compliance automation tool that: # 1. Checks code against GDPR requirements # 2. Validates PCI-DSS compliance for payment code # 3. Ensures HIPAA compliance for health data # 4. Generates compliance reports # 5. Auto-remediates common issues
- Review the implementation
- Create:
security/zero-trust-config/
- Ask Copilot:
Implement zero-trust security architecture with: - mTLS between all services - JWT token validation - API rate limiting - DDoS protection - Encryption at rest and in transit
- Apply to your microservices
- Create:
monitoring/security-dashboard.json
- Ask Copilot:
Create a Grafana dashboard configuration for: - Real-time threat detection - Failed authentication attempts - API abuse patterns - Compliance violations
- Import into Grafana
✅ Checkpoint: Enterprise-grade security and compliance automation is in place
- Create:
performance/ai-load-test.js
- Type:
// Create an AI-powered load testing tool that: // 1. Learns normal traffic patterns // 2. Generates realistic load scenarios // 3. Identifies performance bottlenecks // 4. Suggests optimization strategies // 5. Auto-scales based on predictions
- Run initial test:
node performance/ai-load-test.js --target http://localhost:8080
- Create:
infrastructure/caching-strategy.yaml
- Ask Copilot:
Design a multi-layer caching strategy with: - CDN configuration - Redis for session cache - Application-level caching - AI-powered cache invalidation - Cache warming strategies
- Deploy the configuration
- Create:
database/optimization-scripts/
- For each database table, ask:
Analyze this table structure and suggest: - Index optimizations - Partitioning strategies - Query optimization - Connection pooling configuration
- Apply optimizations incrementally
- Create:
monitoring/performance-alerts.yaml
- Configure alerts for:
- Response time > 200ms
- CPU usage > 80%
- Memory usage > 85%
- Database connection pool exhaustion
✅ Checkpoint: System is optimized for enterprise-scale performance
- Copy the governance template:
cp resources/advanced/module11-governance/enterprise-governance-policy.md ./governance/ai-usage-policy.md
- Customize the policy for your organization:
- Update company-specific requirements
- Adjust security classifications
- Modify compliance requirements
- Set appropriate KPIs
- Review with legal team and stakeholders
- Create:
governance/audit-logger.py
- Type:
# Create an audit logging system that tracks: # 1. All AI tool usage # 2. Code generation events # 3. Security decisions # 4. Performance optimizations # 5. Compliance checks
- Integrate with all services
- Create:
governance/cost-optimizer.py
- Implement:
# Build a cost optimization tool that: # 1. Tracks AI API usage costs # 2. Monitors cloud resource costs # 3. Suggests cost-saving measures # 4. Implements spending limits # 5. Generates cost reports
- Set up automated reports
- Create:
governance/quality-gates.yaml
- Define gates for:
- Code coverage > 80%
- Security score > 90
- Performance benchmarks met
- AI-generated code review passed
- Compliance checks passed
✅ Checkpoint: Complete governance framework is operational
✅ Designing and implementing microservices architecture with AI ✅ Enterprise security scanning and compliance automation ✅ Performance optimization for scale with AI-powered tools ✅ Governance frameworks for AI usage in enterprise ✅ Cost optimization and quality gate implementation
🎯 Scale AI development across your entire organization
The Enterprise Track covers organizational transformation:
📚 Topic | ⏱️ Duration | 🎯 Focus | 🏆 Outcome |
---|---|---|---|
Organizational Readiness | 60 minutes | Change management | Adoption strategy |
Team Training Program | 60 minutes | Skills development | Training framework |
Metrics & ROI | 45 minutes | Success measurement | KPI dashboard |
Continuous Improvement | 45 minutes | Optimization cycle | Process framework |
📁 Enterprise Resources Available:
/resources/enterprise/module12-readiness/enterprise-adoption-template.md
- Complete adoption framework/resources/enterprise/module14-metrics/enterprise-metrics-framework.py
- Metrics collection system/resources/advanced/module11-governance/enterprise-governance-policy.md
- Governance policy template
- Create folder:
enterprise-adoption/assessment/
- Copy the template:
cp resources/enterprise/module12-readiness/enterprise-adoption-template.md ./enterprise-adoption/assessment/
- Create:
assessment/current-state-analysis.md
- In Copilot Chat, type:
Create a comprehensive assessment framework for: - Current development practices maturity - Team AI readiness levels - Infrastructure capabilities - Security and compliance requirements - Budget and resource constraints
- Use the generated framework to assess your organization
- Create:
adoption-roadmap/roadmap.md
- Ask Copilot:
Based on a medium-sized enterprise with 200 developers: - Create a 12-month AI adoption roadmap - Define phases and milestones - Identify required resources - Highlight potential risks and mitigations
- Customize based on your assessment results
- Create:
pilot-program/team-selection-criteria.md
- Define criteria:
# Pilot Team Selection Criteria Ask Copilot to create a scoring matrix for: - Technical proficiency - Innovation mindset - Communication skills - Project complexity - Business impact potential
- Score and select 5-10 pilot team members
- Create:
metrics/kpi-dashboard.json
- Ask Copilot:
Design a KPI dashboard tracking: - Code velocity improvements - Bug reduction rates - Time to market changes - Developer satisfaction scores - Cost savings Include baseline measurements and targets
- Implement using your BI tool of choice
✅ Checkpoint: Organization readiness assessed and pilot program defined
- Create:
training/curriculum-structure.md
- Ask Copilot:
Design a comprehensive AI development training program with: - Beginner track (20 hours) - Intermediate track (40 hours) - Advanced track (60 hours) - Specialized tracks (Security, Performance, Architecture) Include hands-on labs, assessments, and certifications
- Review and adjust for your organization
- Create folders:
training/ ├── beginner/ ├── intermediate/ ├── advanced/ └── specialized/
- For each module, create:
module-guide.md
hands-on-labs.md
assessment-questions.md
- Use Copilot to generate content for each
- Create:
mentorship/program-structure.md
- Design program:
Ask Copilot to create: - Mentor selection criteria - Pairing algorithm - Weekly meeting templates - Progress tracking system - Success metrics
- Launch with pilot team
- Create:
center-of-excellence/charter.md
- Define:
- Mission and objectives
- Roles and responsibilities
- Best practice repository
- Tool evaluation process
- Knowledge sharing forums
- Recruit CoE team members
✅ Checkpoint: Complete training program and CoE established
- Copy the enterprise metrics framework:
cp resources/enterprise/module14-metrics/enterprise-metrics-framework.py ./metrics/measurement-framework.py
- Review the implementation to understand:
- Metric collection methods
- ROI calculation logic
- Report generation
- Recommendation engine
- Customize for your organization:
# Modify these values in the framework: self.developers = 200 # Your team size self.avg_salary = 120000 # Your average salary self.tool_costs = 10000 # Your monthly costs
- Deploy to your development environment
- Create:
roi/roi-calculator.xlsx
orroi-calculator.py
- Include calculations for:
- Developer time saved
- Bug reduction value
- Faster time to market
- Infrastructure cost optimization
- Training investment vs. returns
- Validate with finance team
- Create:
dashboards/executive-summary.json
- Ask Copilot:
Design an executive dashboard showing: - AI adoption progress - Productivity improvements - Cost savings achieved - Risk mitigation status - Competitive advantage metrics
- Implement in PowerBI or Tableau
- Create:
reports/qbr-template.md
- Include sections for:
- Progress against roadmap
- Key achievements
- Challenges and solutions
- ROI demonstration
- Next quarter objectives
- Schedule regular reviews
✅ Checkpoint: Metrics framework operational with clear ROI tracking
- Create:
feedback/collection-system.py
- Implement:
# Build a feedback system that: # 1. Collects developer experiences # 2. Tracks tool effectiveness # 3. Identifies pain points # 4. Suggests improvements # 5. Prioritizes enhancements
- Deploy across all teams
- Create:
evaluation/tool-evaluation-framework.md
- Define process for:
- New AI tool discovery
- Evaluation criteria
- Pilot testing approach
- Security assessment
- Adoption decision matrix
- Run monthly evaluations
- Create:
best-practices/
- Organize by:
best-practices/ ├── code-generation/ ├── security-patterns/ ├── performance-optimization/ ├── testing-strategies/ └── architecture-patterns/
- Populate with team contributions
- Create:
innovation-labs/lab-charter.md
- Establish:
- Weekly innovation time
- Hackathon schedule
- Proof of concept process
- Success story sharing
- Patent/IP process
- Launch first innovation challenge
✅ Checkpoint: Continuous improvement cycle fully operational
✅ How to assess organizational readiness for AI adoption ✅ Building comprehensive training and mentorship programs ✅ Implementing metrics frameworks with ROI tracking ✅ Creating continuous improvement processes ✅ Scaling AI development practices across large organizations
🤖 AI Development Mastery:
- GitHub Copilot successfully installed and authenticated
- Generated first production-quality code with AI assistance
- Mastered prompt engineering for better AI suggestions
- Understood AI limitations and best practices
⚡ Performance Optimization:
- Identified performance bottlenecks in existing code
- Implemented StringBuilder optimization (10x+ improvement)
- Measured and documented performance gains
- Applied optimization patterns to real-world scenarios
🔒 Security Implementation:
- Identified SQL injection vulnerabilities
- Implemented parameterized queries
- Added comprehensive input validation
- Applied security patterns across codebase
🎯 Metric | 🔰 Before Workshop | 🥇 After Workshop | 📈 Improvement |
---|---|---|---|
Code Generation Speed | 50 lines/hour | 150+ lines/hour | 3x faster |
Bug Detection Rate | Manual review only | AI-assisted detection | 50% more bugs found |
Security Awareness | Basic knowledge | Production-ready patterns | Enterprise-level |
Development Confidence | Uncertain with new tech | AI-first approach | High confidence |
graph TD
A[🎓 Core Workshop Complete] --> B{🎯 Career Goals?}
B -->|🔧 Technical Depth| C[🔧 Advanced Track<br/>2 hours]
B -->|🏢 Enterprise Focus| D[🏢 Enterprise Track<br/>3+ hours]
B -->|📚 Self-Paced Learning| E[📚 Resource Library<br/>Self-guided]
C --> F[🤝 Multi-Agent Systems]
C --> G[🔄 Advanced CI/CD]
D --> H[📋 Enterprise Governance]
D --> I[📊 Scalability Patterns]
E --> J[🛠️ Automation Scripts]
E --> K[💻 Code Examples]
style A fill:#e8f5e8
style F fill:#e3f2fd
style H fill:#fff3e0
🎯 Learning Path | ⏱️ Time Investment | 🏆 Outcome | 🔗 Start Here |
---|---|---|---|
🔧 Advanced Technical Track | 2 hours | Multi-agent systems, advanced CI/CD | Advanced Track Guide |
🏢 Enterprise Implementation | 3+ hours | Enterprise governance, scalability | Enterprise Track Guide |
📚 Self-Guided Learning | Flexible | Explore automation resources | Resources Directory |
Ready-to-Use Enterprise Assets:
- Infrastructure Automation:
setup-azure-infrastructure.sh
|cleanup-azure-infrastructure.sh
- Environment Validation:
validate-setup.sh
- CI/CD Templates:
github-actions-workflow.yml
|azure-devops-pipeline.yml
- Production Code Examples:
DatabaseConnection.java
|DatabaseConnection.cs
- Configuration Templates:
application.properties
|appsettings.json
- Multi-Agent Orchestration:
multi_agent_orchestrator.py
Immediate Actions (Next 24 hours):
- "Apply AI techniques to your current project"
- "Set up CI/CD pipeline using our templates"
- "Share workshop learnings with your team"
- "Schedule follow-up practice sessions"
Week 1 Goals:
- "Integrate GitHub Copilot into daily workflow"
- "Implement security patterns in production code"
- "Measure and document productivity improvements"
- "Begin advanced track if applicable"
Month 1 Objectives:
- "Lead AI development adoption in your organization"
- "Contribute to enterprise AI governance policies"
- "Mentor other developers in AI-assisted development"
- "Complete enterprise track for full certification"
Previous | Up | Next |
---|---|---|
⬅️ Module 1: AI Introduction | 📖 Main README | ➡️ Module 3: Troubleshooting |