---

Duration: 3 days (instructor-led, hands-on)
Format: 30% guided instruction & demos, 60% labs, 10% exam-style practice
Audience: Developers, DevOps, Security, QA, PMs, Engineering Leads
Assumed level: Participants already know GitLab basics (repos, issues, MRs, pipelines)

---

1) Introduction

GitLab Duo brings AI assistance into everyday GitLab workflows (coding, reviewing, CI/CD troubleshooting, security understanding, documentation, collaboration). This course makes learners confident and fast with Duo in real delivery work, while also preparing them for the Certified GitLab Duo (AI) Associate exam through daily exam-style practice and a final mock.

---

2) Course Overview

This is an end-to-end, workflow-based program using one continuous project scenario. Participants learn to apply GitLab Duo to:

• accelerate implementation, refactoring, and understanding of existing code
• improve test quality, coverage, and review readiness
• interpret findings (security/quality) and remediate effectively
• troubleshoot CI failures and optimize pipelines
• improve collaboration artifacts (issues, MRs, docs, handoffs)
• use Duo responsibly: governance, data sensitivity, and quality control

---

3) Learning Objectives

A) GitLab Duo Advanced Practitioner Outcomes

By the end of Day 3, participants can:

1. Configure and govern Duo usage at group/project level (where applicable), and understand who can access what.
2. Use Duo effectively in IDE + GitLab UI with strong prompting patterns and “verification-first” habits.
3. Apply Duo to advanced coding tasks: generate, refactor, explain, optimize, and document changes.
4. Use Duo to strengthen MR quality: better descriptions, reviewer guidance, risk notes, and checklists.
5. Use Duo to improve test strategy and create meaningful unit/integration tests (not just “happy path”).
6. Use Duo to support security understanding and remediation, and document fixes clearly.
7. Use Duo to accelerate CI/CD authoring and perform structured failure analysis from logs.
8. Measure outcomes and run Duo adoption safely: quality gates, prompt standards, and ROI signals.

B) Certification Readiness Outcomes

Participants will also be able to:

9. Identify exam-style scenario patterns and avoid common pitfalls (over-trusting AI output, skipping verification).
10. Explain Duo capabilities, limitations, and responsible usage in clear terms (the kind exams test).
11. Perform timed question sets with a repeatable strategy.

---

4) Participant Profile & Prerequisites

Prerequisites (required)

• Basic GitLab workflow knowledge: repository, branches, merge requests, issues
• Basic CI/CD familiarity: pipelines, jobs, logs
• General understanding of testing and security basics (what they are, not deep expertise)

Recommended (helpful)

• Experience reviewing MRs
• Familiarity with one programming language used in your org
• Comfort reading pipeline logs and stack traces

---

5) What This Course Is (and Isn’t)

This course is: practical, hands-on, workflow-based, focused on real productivity and exam readiness.
This course isn’t: a Git fundamentals class, or a deep ML/AI theory course.

---

6) Delivery Approach

• Instructor uses live demos to show “good vs risky” AI usage patterns
• Labs emphasize:
  • constraint-based prompting
  • verification (tests, lint, pipeline checks)
  • MR-ready outputs
  • security and compliance awareness
• Daily: exam-style mini quiz + scenario debrief
• End: capstone + mock exam workshop

---

7) Lab Environment & Materials

Tools needed

• GitLab instance with GitLab Duo enabled (or training environment)
• IDE support: VS Code / JetBrains (preferred) or Web IDE
• A prepared training repository (“AcmePay”) containing:
  • at least one legacy module
  • incomplete tests
  • intentionally flawed pipeline job
  • intentionally introduced vulnerability or insecure pattern
  • issue + MR templates (basic)

Working agreements (important)

• Treat AI output as a draft: verify before merge
• Do not paste secrets or sensitive data into prompts
• Use the prompt checklist provided in Appendix A

---

8) Core Use-Case Story (Capstone Scenario)

Scenario: “AcmePay” Microservice Modernization

A payment API repository has:

• a new feature request with partial legacy code
• weak test coverage and missing edge-case tests
• insecure configuration or dependency vulnerability
• flaky CI pipeline and unclear logs
• poor MR descriptions and limited documentation

Across 3 days, participants will use GitLab Duo to:

1. implement/refactor safely,
2. generate and improve tests,
3. understand and remediate security issues,
4. troubleshoot CI failures and optimize pipelines,
5. produce clean MRs and documentation,
6. summarize impact and adoption signals.

---

9) Day-wise Agenda (3 Days)

Day 1 — Duo Foundations + Advanced Development & MR Excellence

Theme: “Be productive fast, but safely.”

Time	Session	What participants achieve
09:00–09:30	Orientation + course goals	Understand capstone and how exam prep is embedded
09:30–10:30	Duo capability map + where it fits	Know “what to use where” across IDE, MR, pipelines, security
10:45–11:45	Governance + safe usage practices	Access patterns, data sensitivity, responsible AI behavior
11:45–12:30	Prompting patterns (advanced)	Convert vague asks into reliable, verifiable instructions
13:30–15:00	Advanced coding workflows with Duo	Generate/refactor/explain with constraints + verification
15:15–16:30	MR excellence with Duo	Produce MR summaries, risk notes, test plans, review checklists
16:30–17:30	Exam practice block (Day 1)	15 timed questions + debrief (why each option is right/wrong)

Day 1 Labs (hands-on)

1. Environment warm-up: Duo access, IDE connection, repo walkthrough
2. Feature build with guardrails: implement a new endpoint/module with constraints:
   • style rules
   • error handling
   • logging
   • testability requirements
3. Legacy code comprehension: ask Duo to explain, then create a refactor plan
4. Refactor execution: apply refactor + minimal tests
5. MR packaging: generate:
   • MR description
   • change summary
   • risk notes & rollback hint
   • reviewer checklist

Day 1 Deliverables

• One MR opened with strong description and checklist
• Refactor plan notes + implemented improvement

---

Day 2 — Testing & Security: Quality That Scales

Theme: “Make AI raise quality, not just speed.”

Time	Session	What participants achieve
09:00–10:15	AI-assisted test strategy	Decide what to test, not just generate tests
10:30–12:00	Test generation + coverage uplift lab	Create meaningful tests (edge cases + negative tests)
13:00–14:15	Secure coding with Duo	Use AI to explain risks and propose safer patterns
14:15–15:15	Remediation workflow	Implement fixes + document security decisions clearly
15:30–16:15	MR review simulation	Use Duo to help structure review comments and verify changes
16:15–17:30	Exam practice block (Day 2)	15 timed questions + weak-area drills

Day 2 Labs (hands-on)

1. Test suite build-out for feature and refactor:
   • unit tests with edge cases
   • failure-path tests
   • simple integration tests if applicable
2. Quality uplift:
   • identify gaps
   • improve assertions
   • remove flaky patterns
3. Security investigation:
   • use Duo to explain a vulnerability or insecure code pattern
   • propose remediation options with tradeoffs
4. Remediation + verification:
   • implement fix
   • pipeline run
   • produce security-focused MR notes

Day 2 Deliverables

• Increased test coverage and improved test quality
• Security fix documented in MR notes (what, why, how verified)

---

Day 3 — CI/CD Troubleshooting + Collaboration + Full Certification Prep

Theme: “Operate Duo at team scale; finish exam-ready.”

Time	Session	What participants achieve
09:00–10:15	AI-assisted CI/CD authoring	Generate/optimize pipeline changes safely
10:30–12:00	Failure analysis & root cause workflows	Use Duo to form hypotheses + verification steps from logs
13:00–14:00	Duo for collaboration & documentation	Create issue updates, release notes, and handoffs
14:00–14:45	Measuring impact + adoption standards	Define KPIs and guardrails; create team prompt standards
15:00–16:15	Capstone execution	End-to-end: build → test → secure → ship with Duo
16:15–17:30	Mock exam + review workshop	Timed mini-mock + remediation plan for each learner

Day 3 Labs (hands-on)

1. Pipeline improvement:
   • improve job clarity and failure output
   • reduce flakiness
   • add missing verification step(s)
2. CI failure root cause:
   • interpret failing logs
   • ask Duo for likely causes + confidence
   • validate with targeted checks
3. Documentation & comms:
   • release note draft
   • issue update summary
   • QA handoff checklist
4. Impact plan:
   • define 3 KPIs (speed + quality + risk)
   • create “AI usage guardrails” checklist for your team

Day 3 Deliverables

• Pipeline MR + documented reasoning
• Capstone MR with complete evidence (tests, pipeline, notes)
• Personal certification action plan (what to review next)

---

10) Use Case Library (examples included in exercises)

Development & Refactoring

• Convert a vague feature request into a clean implementation plan + code
• Explain legacy logic and propose refactor steps that minimize risk
• Generate code with constraints (style, performance, security, testability)

Merge Requests & Review

• Produce high-quality MR descriptions and summaries
• Generate reviewer checklists and test plans
• Write constructive review comments; identify risky changes

Testing

• Generate meaningful tests from requirements + edge cases
• Improve assertions and reliability; avoid brittle tests
• Create a test matrix for critical flows

Security

• Explain vulnerability cause, impact, exploit scenario
• Suggest remediation options with pros/cons
• Document security decisions and verification evidence

CI/CD

• Generate or refine .gitlab-ci.yml changes responsibly
• Troubleshoot failing jobs using structured hypothesis prompts
• Improve pipeline observability (logs, artifacts, clarity)

Collaboration & Enablement

• Draft release notes and stakeholder updates
• Create reusable prompt templates for team consistency
• Define metrics and safe adoption practices

---

11) Assessment & Completion Criteria

Daily checks

• End of each day: 15 exam-style questions (timed) + review

Capstone rubric (pass/fail)

Participants pass if they demonstrate:

• Correct use of Duo with clear prompts + constraints
• Verification evidence (tests and/or pipeline results)
• MR quality: summary, rationale, risks, test plan, rollback hint
• Security handling: explain issue + implement fix or mitigation + document
• Operational clarity: pipeline change justified and validated
• Impact summary: what improved and how you know

---