Building Software Using GitHub Copilot

Module 1: Course Kickoff and One-Day Objectives (20 minutes)

• Instructor introduction and workshop logistics
• What "above and beyond" means versus a fundamentals/adoption class
• Learning Objectives:
  • Build production-ready software using agentic AI and multi-agent collaboration
  • Define and enforce coding standards in AI-assisted development
  • Configure agent roles, context, and responsibilities for delivery
  • Integrate agents into end-to-end software lifecycle workflows
• Environment validation (IDE, Copilot access, repository, test tooling)

Module 2: Agentic Software Engineering Foundations (40 minutes)

• From pair programming to agentic software development
• Agent capabilities across the SDLC:
  • Planning and architecture
  • Code generation and refactoring
  • Test generation and execution
  • Security and quality analysis
  • Documentation and release support
• Selecting when to use single-agent vs. multi-agent workflows
• Human-in-the-loop controls and decision checkpoints

Module 3: Multi-Agent Architecture for Software Delivery (50 minutes)

• Designing agent roles and specialization:
  • Product/requirements agent
  • Architecture/design agent
  • Implementation agent
  • Test/quality agent
  • Security/compliance agent
  • Documentation/release agent
• Coordination patterns:
  • Sequential handoff
  • Parallel tasking
  • Reviewer-implementer loops
• Shared context strategy:
  • Repository and workspace context
  • Requirement artifacts and acceptance criteria
  • ADRs and coding standards references
• Exercise: Create a role map and interaction model for a sample project

Module 4: Setting Up Agent Information and Guardrails (45 minutes)

• Agent setup practices for consistent outcomes:
  • Role prompts and operating instructions
  • Input contracts and expected outputs
  • Tool access boundaries and escalation paths
• Creating standards-aware instructions:
  • Naming conventions
  • Error-handling patterns
  • Logging and observability expectations
  • Code review checklist criteria
• Context packaging for multi-agent reuse (templates/playbooks)
• Exercise: Build and validate a starter multi-agent configuration

Module 5: Coding Standards and Quality Standards in Agentic Development (50 minutes)

• Translating team standards into enforceable AI workflows
• Standards coverage:
  • Style and formatting rules
  • SOLID/clean-code principles
  • Secure coding standards (OWASP-aligned practices)
  • Test quality criteria (reliability, maintainability, traceability)
• Quality gates for AI-generated code:
  • Linting and static analysis
  • Unit/integration test thresholds
  • Security scanning and dependency checks
• Exercise: Apply a standards policy to generated code and iterate to pass gates

Module 6: Building Features with Multi-Agent Workflows (60 minutes)

• Feature delivery pipeline with agents:
  • Break requirements into implementation tasks
  • Generate skeletons and domain logic
  • Add API/service contracts and data models
  • Review and refine implementation decisions
• Managing prompt/context drift during long-running tasks
• Ensuring deterministic outputs and reproducible builds
• Hands-on lab: Implement a feature end-to-end with role-based agents

Module 7: Automated Testing and Continuous Verification (45 minutes)

• Agent-assisted testing strategy for software delivery:
  • Unit tests for business logic
  • Component/service tests for boundaries
  • API and integration tests for contracts
  • Smoke/system tests for core flows
• Triggering and evaluating tests automatically in CI pipelines
• Handling code changes:
  • Updating tests when interfaces evolve
  • Detecting brittle tests and reducing false positives
• Exercise: Configure agents to generate, run, and update tests for a changed feature

Module 8: Security, Compliance, and Risk Controls (35 minutes)

• Secure-by-default agent workflows
• Common AI-assisted coding risks:
  • Hallucinated APIs/libraries
  • Insecure patterns
  • Secret leakage
• Policy enforcement and evidence collection for audits
• Exercise: Run a security review loop with implementation and security agents

Module 9: One-Day Capstone Build (120 minutes)

• Goal: Deliver a small production-style service using multi-agent orchestration
• Phase 1: Planning and architecture (20 min)
• Phase 2: Feature implementation (45 min)
• Phase 3: Tests and quality gates (30 min)
• Phase 4: Security/compliance review and documentation (25 min)
• Deliverables:
  • Working code
  • Passing test and quality checks
  • Agent configuration artifacts
  • Coding standards compliance summary

Module 10: Wrap-Up and Adoption Plan (15 minutes)

• Recap of key practices for multi-agent software development
• Team rollout plan for one repo and one pilot squad
• Metrics for success:
  • Lead time and cycle time
  • Defect escape rate
  • Rework due to standards violations
• Final Q&A and next-step resources