Skip to main content

Workshop Catalog -- Hands-On AEEF Training

Not every team needs a full certification track. Sometimes you need a focused session that delivers a specific outcome in a single sitting -- a Tier 1 deployment in 30 minutes, a CI pipeline hardened in an afternoon, or a strategic roadmap drafted before the end of the day.

This catalog contains 8 standalone workshops that can be delivered independently of the certification program. Each workshop is self-contained with its own objectives, prerequisites, materials, and hands-on exercises. Workshops can also be combined into multi-day events for organizations that want broader coverage without committing to full certification tracks.

Workshop Overview​

#WorkshopAudienceDurationKey Outcome
1AEEF in 30 MinutesAnyone30 minTier 1 deployed on a project
2AI Governance for CTOsCTO, VP Eng, Directors2 hoursGovernance decision + adoption timeline
3Agent SDLC Deep DiveArchitects, Senior Engineers4 hoursAgent SDLC configured for their project
4CI Pipeline HardeningDevOps, Platform Engineers4 hoursProduction-grade CI pipeline running
5Multi-Agent OrchestrationSenior Engineers, Architects8 hoursMulti-agent workflow with governance
6Compliance & SovereigntyCompliance, Legal, Security4 hoursCompliance overlay configured
7AEEF CLI MasteryDevelopers, Tech Leads4 hoursFull 4-role workflow running
8From Vibe Coding to Agentic EngineeringEngineering Leaders, Team Leads2 hoursTransformation roadmap drafted

Workshop 1: AEEF in 30 Minutes (All Levels)​

Overview​

The fastest path from zero to governed. In 30 minutes, every participant will have Tier 1 AEEF governance running on a real project. This workshop is designed for team-wide kickoffs, onboarding sessions, or conference demos.

Details​

AttributeDetail
AudienceAnyone -- developers, managers, executives, non-technical stakeholders
Duration30 minutes
Technical LevelBeginner (copy-paste friendly)
PrerequisitesGitHub account, Git installed, one existing repository
Materialsaeef-quickstart repo, aeef-config-packs repo
OutcomeTier 1 governance deployed on one project

Agenda​

TimeActivity
0:00-0:05Introduction: what AEEF is and why it matters (2 slides)
0:05-0:10Clone aeef-quickstart or download config packs
0:10-0:20Apply config packs to your project: AI rules, CI pipeline, PR template
0:20-0:25Push changes and verify CI pipeline runs
0:25-0:30Create a PR using the AEEF template, verify AI disclosure section

Hands-On Exercise​

Goal: Apply Tier 1 governance to one of your repositories in under 20 minutes.

  1. Choose a repository you have push access to
  2. Download the appropriate config pack from aeef-config-packs:
    • ai-tool-config/ -- rules for your AI tool
    • ci-pipelines/github-actions/ -- CI workflow
    • pr-templates/ -- PR template with AI disclosure
  3. Copy the files into your repository
  4. Commit, push, and verify the pipeline runs
  5. Open a PR and fill in the AI disclosure section

Success criteria: CI pipeline runs green and PR template shows AI disclosure section.

Post-Workshop Resources​

Workshop 2: AI Governance for CTOs (Executive)​

Overview​

A strategic briefing designed for technical leadership. This workshop presents the market data, risk landscape, ROI framework, and case studies that executives need to make informed decisions about AI coding governance. No coding required -- this is a decision-support session.

Details​

AttributeDetail
AudienceCTO, VP Engineering, Engineering Directors, Technical Advisors
Duration2 hours
Technical LevelNon-technical (business and strategy focused)
PrerequisitesNone (pre-read materials provided 1 week before)
MaterialsSlide deck, ROI calculator spreadsheet, case study packet
OutcomeDecision on AEEF tier + adoption timeline documented

Agenda​

TimeActivity
0:00-0:20Market landscape: $4-7B market, adoption rates, competitive dynamics
0:20-0:40The productivity paradox: Faros AI, METR, Uplevel data
0:40-1:00Real incidents and risk data: what happens without governance
1:00-1:20ROI framework: calculating return on governance investment
1:20-1:40Case studies: organizations that adopted governance successfully
1:40-2:00Decision exercise: choose tier, set timeline, define success metrics

Hands-On Exercise​

Goal: Make a governance decision and document it.

  1. Review the tier comparison matrix with your organization's profile
  2. Use the ROI calculator to estimate investment and return
  3. Select a target tier for each team or business unit
  4. Define a 6-week adoption timeline with weekly milestones
  5. Document 3 success metrics you will track

Success criteria: Documented governance decision with tier selection, timeline, and metrics.

Discussion Topics​

  • How does AI governance affect our competitive position?
  • What is the cost of NOT governing AI coding? (Risk quantification exercise)
  • How do we balance developer autonomy with organizational governance?
  • What regulatory requirements apply to our industry and jurisdiction?
  • How do we measure success -- and how quickly should we expect results?

Post-Workshop Resources​

Workshop 3: Agent SDLC Deep Dive (Technical)​

Overview​

A technical deep dive into the AEEF Agent SDLC -- the multi-agent development lifecycle that structures how AI agents collaborate on software projects. Participants design agent pipelines, author contracts, define handoff protocols, and configure the agent SDLC for their own projects.

Details​

AttributeDetail
AudienceSolution Architects, System Architects, Senior Engineers, Tech Leads
Duration4 hours
Technical LevelIntermediate to advanced
PrerequisitesFamiliarity with Git, CI/CD, code review processes
Materialsaeef-cli repo, aeef-transform repo, contract templates
OutcomeAgent SDLC configured for one of their projects

Agenda​

TimeActivity
0:00-0:30The case for multi-agent development: why 4 agents, not 1
0:30-1:00The 4-agent model: product, architect, developer, QC
1:00-1:30Contract authoring: structure, constraints, permissions, outputs
1:30-2:00Hands-on: write contracts for all 4 roles
2:00-2:15Break
2:15-2:45Handoff protocols: PR-based handoffs, branch naming, artifacts
2:45-3:15The 11-agent model: when and why to scale beyond 4 agents
3:15-3:45Hands-on: configure Agent SDLC for your project
3:45-4:00Review and Q&A

Hands-On Exercises​

Exercise 1: Contract Authoring (30 minutes)

Write agent contracts for all 4 roles in the AEEF 4-agent model, customized for a project you work on:

  1. Define the role description, permissions, and constraints for each agent
  2. Specify required outputs and forbidden actions
  3. Define handoff criteria: what must be true before an agent can hand off to the next
  4. Peer review contracts with another participant

Exercise 2: Agent SDLC Configuration (30 minutes)

Configure the Agent SDLC for a real project using the AEEF CLI or aeef-transform templates:

  1. Initialize the agent SDLC directory structure
  2. Place contracts for all 4 roles
  3. Configure handoff PR templates
  4. Define quality gates for each transition
  5. Run a dry-run simulation of the workflow

Success criteria: Complete 4-agent contract set and configured SDLC directory for a real project.

Key Takeaways​

  • Contracts are the most important governance artifact -- they define what each agent can and cannot do
  • Handoffs via PR ensure auditability and human review points
  • Start with 4 agents; scale to 11 only when organizational complexity demands it
  • The agent SDLC is a process design, not a tool dependency -- it works with any AI coding tool

Post-Workshop Resources​

Workshop 4: CI Pipeline Hardening (Technical)​

Overview​

A hands-on workshop for DevOps engineers and platform teams focused on building production-grade CI pipelines that enforce AEEF governance. Participants configure multi-stage pipelines with lint, test, SAST, SCA, mutation testing, drift detection, and quality gate enforcement.

Details​

AttributeDetail
AudienceDevOps Engineers, Platform Engineers, SREs, Senior Developers
Duration4 hours
Technical LevelIntermediate to advanced
PrerequisitesCI/CD experience (GitHub Actions, GitLab CI, or similar), Docker
Materialsaeef-transform repo (CI workflows), aeef-config-packs repo
OutcomeProduction-grade CI pipeline running on their project

Agenda​

TimeActivity
0:00-0:30AEEF CI architecture: 9-stage pipeline overview
0:30-1:00Stage 1-3: Lint, format, type checking (language-specific)
1:00-1:30Stage 4-5: Unit tests, integration tests, coverage thresholds
1:30-2:00Hands-on: configure stages 1-5 for your project
2:00-2:15Break
2:15-2:45Stage 6-7: Semgrep SAST, SCA scanning, custom rules
2:45-3:15Stage 8-9: Mutation testing, drift detection, quality gates
3:15-3:45Hands-on: configure stages 6-9 and verify full pipeline
3:45-4:00Pipeline optimization: caching, parallelism, failure modes

Hands-On Exercises​

Exercise 1: Core Pipeline (30 minutes)

Configure the first 5 stages of the AEEF CI pipeline for your project:

  1. Select the appropriate language template (TypeScript, Python, or Go)
  2. Configure linting: ESLint flat config, ruff + mypy, or golangci-lint (28 linters)
  3. Configure testing: Vitest, pytest-cov, or go test with coverage
  4. Set coverage thresholds (recommendation: 80% line, 70% branch)
  5. Verify all 5 stages pass on a clean run

Exercise 2: Security and Quality Pipeline (30 minutes)

Add the advanced stages that distinguish AEEF governance from basic CI:

  1. Add Semgrep with the AEEF rule pack for your language (7 rules for TypeScript, 5 for Python, 5 for Go)
  2. Write 1 custom Semgrep rule specific to your project
  3. Configure mutation testing: Stryker, mutmut, or go-mutesting
  4. Add drift detection: checksum comparison for governed config files
  5. Configure the quality gate: define pass/fail criteria across all stages

Success criteria: Full 9-stage pipeline running green with all checks required for merge.

Pipeline Architecture Reference​

Stage 1: Lint          ─┐
Stage 2: Format         ├─ Fast feedback (< 2 min)
Stage 3: Type Check    ─┘
Stage 4: Unit Tests    ─┐
Stage 5: Integration    ├─ Correctness (< 5 min)
Stage 6: SAST (Semgrep)─┘
Stage 7: SCA Scan      ─┐
Stage 8: Mutation Test   ├─ Deep quality (< 15 min)
Stage 9: Drift + Gate  ─┘

Post-Workshop Resources​

Workshop 5: Multi-Agent Orchestration (Advanced)​

Overview​

A full-day advanced workshop covering multi-agent orchestration patterns, tool integration, and governance for complex agent workflows. This is the most technically demanding workshop in the catalog, designed for engineers who will design and maintain multi-agent systems.

Details​

AttributeDetail
AudienceSenior Engineers, Solution Architects, AI/ML Engineers
Duration8 hours (full day)
Technical LevelAdvanced
PrerequisitesDeveloper Certification Module 4+ or equivalent experience, Docker, familiarity with at least one orchestration tool
Materialsaeef-cli repo, aeef-transform repo, sample orchestration configs
OutcomeMulti-agent workflow running with AEEF governance

Agenda​

TimeActivity
0:00-0:45Orchestration patterns: sequential, parallel, hierarchical, peer review
0:45-1:30Pattern selection framework: matching patterns to project types
1:30-2:15Tool landscape: AEEF CLI, CrewAI, claude-flow, Composio, OpenClaw
2:15-3:00Hands-on: implement sequential workflow with AEEF CLI
3:00-3:30Lunch break
3:30-4:15Git-branch isolation: branch-per-role, branch-per-task, branch-per-component
4:15-5:00Hands-on: implement parallel workflow with branch-per-component
5:00-5:45Governance integration: injecting AEEF controls into any orchestrator
5:45-6:30Hands-on: integrate AEEF governance with a third-party orchestrator
6:30-7:00Advanced patterns: feedback loops, human-in-the-loop, escalation chains
7:00-7:30Architecture review: participants present their designs
7:30-8:00Wrap-up, Q&A, next steps

Hands-On Exercises​

Exercise 1: Sequential Workflow (45 minutes)

Implement the standard AEEF 4-agent sequential workflow:

  1. Install and configure the AEEF CLI
  2. Define contracts for product, architect, developer, and QC roles
  3. Execute the full workflow on a sample project
  4. Review the PR chain and verify handoff artifacts
  5. Identify bottlenecks and propose optimizations

Exercise 2: Parallel Workflow (45 minutes)

Implement a parallel agent workflow with branch-per-component isolation:

  1. Define 3 agent roles: frontend agent, backend agent, integration agent
  2. Create branch isolation: feature/frontend, feature/backend
  3. Run frontend and backend agents in parallel
  4. Run integration agent to validate compatibility and merge
  5. Verify governance controls applied to all branches

Exercise 3: Third-Party Integration (45 minutes)

Integrate AEEF governance with a third-party orchestration tool:

  1. Choose one: CrewAI, claude-flow, Composio, or OpenClaw
  2. Configure the tool with AEEF agent contracts
  3. Add governance hooks: pre-execution contract validation, post-execution quality check
  4. Execute a workflow and verify governance enforcement
  5. Compare the experience with the AEEF CLI approach

Success criteria: At least 2 of 3 exercises completed with working governance integration.

Pattern Reference​

PatternBest ForAEEF SupportComplexity
SequentialMost projects, strong audit trailNative (CLI default)Low
ParallelIndependent components, speed-criticalBranch-per-componentMedium
HierarchicalLarge projects, supervisor oversightEnterprise role packHigh
Peer ReviewSafety-critical code, high-assuranceDual-agent with diffMedium
Pipeline + FeedbackIterative refinement, complex featuresCustom hook chainsHigh

Post-Workshop Resources​

Workshop 6: Compliance & Sovereignty (Governance)​

Overview​

A governance-focused workshop for compliance officers, legal teams, and security professionals. Participants learn how AEEF maps to regulatory requirements, configure sovereign overlays for their jurisdiction, generate audit evidence, and build compliance dashboards.

Details​

AttributeDetail
AudienceCompliance Officers, Legal Counsel, Security Architects, DPOs
Duration4 hours
Technical LevelNon-technical (configuration and policy focused)
PrerequisitesFamiliarity with regulatory requirements in your jurisdiction
Materialsaeef-production repo (overlay templates), compliance mapping spreadsheet
OutcomeCompliance overlay configured for their jurisdiction

Agenda​

TimeActivity
0:00-0:30AI coding in the regulatory landscape: what regulators care about
0:30-1:00AEEF standards as compliance controls: mapping framework
1:00-1:30Sovereign overlays: KSA, UAE, Egypt, EU configurations
1:30-2:00Hands-on: configure overlay for your jurisdiction
2:00-2:15Break
2:15-2:45Audit evidence generation: artifacts, collection, reporting
2:45-3:15Compliance dashboards: metrics that auditors want to see
3:15-3:45Hands-on: build an evidence collection checklist
3:45-4:00Regulatory outlook: upcoming requirements and preparation

Hands-On Exercises​

Exercise 1: Sovereign Overlay Configuration (30 minutes)

Configure a compliance overlay for your jurisdiction:

  1. Review the overlay templates in aeef-production/shared/overlays/
  2. Select the overlay matching your primary jurisdiction (KSA, UAE, Egypt, or EU)
  3. Customize the overlay for your organization's specific requirements
  4. Map AEEF standards to your jurisdiction's regulatory controls
  5. Document any gaps that require additional controls

Exercise 2: Evidence Collection Checklist (30 minutes)

Build an audit-ready evidence collection strategy:

  1. List all AEEF artifacts that serve as compliance evidence
  2. Map each artifact to specific regulatory requirements
  3. Define collection frequency (real-time, daily, weekly, monthly)
  4. Identify storage and retention requirements
  5. Draft an audit preparation checklist

Success criteria: Overlay configured for one jurisdiction with regulatory mapping and evidence checklist.

Regulatory Coverage​

JurisdictionKey RegulationsAEEF OverlayStandards Mapped
KSASDAIA AI Ethics, NDMOoverlays/ksa/PRD-STD-009 through 016
UAEAI Office Framework, DIFC/ADGMoverlays/uae/PRD-STD-009 through 016
EgyptNational AI Strategy, CBE Tech Govoverlays/eg/PRD-STD-009 through 016
EUEU AI Act, GDPR, DSAoverlays/eu/PRD-STD-009 through 016

Post-Workshop Resources​

Workshop 7: AEEF CLI Mastery (Hands-On)​

Overview​

A hands-on workshop dedicated to the AEEF CLI wrapper. Participants install the CLI, run complete 4-role workflows, author custom hooks, create skills, and learn to extend the CLI for their team's specific needs.

Details​

AttributeDetail
AudienceSoftware Developers, Tech Leads, DevOps Engineers
Duration4 hours
Technical LevelIntermediate
PrerequisitesClaude Code installed, Git proficiency, bash familiarity
Materialsaeef-cli repo, sample projects for each language stack
OutcomeFull 4-role workflow running on their project

Agenda​

TimeActivity
0:00-0:30CLI architecture: how aeef wraps Claude Code
0:30-1:00Installation and initialization: aeef init, .claude/ setup
1:00-1:30Hands-on: run your first 4-role workflow
1:30-2:00Hook system: PreToolUse, PostToolUse, Stop, session-start
2:00-2:15Break
2:15-2:45Hands-on: write a custom hook for your project
2:45-3:15Skills: /aeef-handoff, /aeef-gate, /aeef-provenance
3:15-3:45Hands-on: create a custom skill for your workflow
3:45-4:00Advanced: custom roles, model selection, team configuration

Hands-On Exercises​

Exercise 1: First 4-Role Workflow (30 minutes)

Run a complete agent workflow from product to main:

  1. Clone and install the AEEF CLI
  2. Initialize a project with aeef init
  3. Run aeef --role=product -- create a user story
  4. Run aeef --role=architect -- design the solution
  5. Run aeef --role=developer -- implement the code
  6. Run aeef --role=qc -- validate and test
  7. Review the PR chain on GitHub

Exercise 2: Custom Hook (30 minutes)

Write a custom pre-tool-use hook that enforces a project-specific constraint:

  1. Review the existing hooks/pre-tool-use.sh for patterns
  2. Identify a constraint specific to your project (e.g., no writes to config/ except by architect)
  3. Write a bash hook that checks tool invocations against the constraint
  4. Register the hook in .claude/settings.json
  5. Test the hook by triggering a violation

Exercise 3: Custom Skill (30 minutes)

Create a custom skill that extends the AEEF workflow:

  1. Review the existing skills: /aeef-handoff, /aeef-gate, /aeef-provenance
  2. Design a skill for your team's workflow (e.g., /aeef-deploy, /aeef-review, /aeef-docs)
  3. Create the skill file with proper metadata and instructions
  4. Register the skill in the CLI configuration
  5. Test the skill in a Claude Code session

Success criteria: Complete 4-role workflow executed, at least 1 custom hook or skill created.

CLI Quick Reference​

# Installation
git clone https://github.com/AEEF-AI/aeef-cli.git
cd aeef-cli && ./install.sh

# Initialize a project
aeef init

# Run agent roles
aeef --role=product      # Create stories -> PR to architect
aeef --role=architect    # Design architecture -> PR to dev
aeef --role=developer    # Implement code -> PR to QC
aeef --role=qc           # Validate + test -> PR to main

# Options
aeef --role=developer --model=claude-opus-4-6
aeef --role=architect --verbose
aeef --status            # Show workflow status

Post-Workshop Resources​

Workshop 8: From Vibe Coding to Agentic Engineering (Strategic)​

Overview​

A strategic session for engineering leaders exploring the industry evolution from unstructured AI coding ("vibe coding") to governed, multi-agent engineering. This workshop presents the maturity spectrum, case studies from organizations at different stages, and a framework for planning the transformation.

Details​

AttributeDetail
AudienceEngineering Leaders, Team Leads, VP Engineering, CTOs
Duration2 hours
Technical LevelNon-technical (strategic and organizational)
PrerequisitesNone
MaterialsSlide deck, transformation planning template, case study packet
OutcomeTransformation roadmap drafted for their organization

Agenda​

TimeActivity
0:00-0:20The maturity spectrum: from vibe coding to agentic engineering
0:20-0:40Industry evolution: how the market is moving (2024-2026 trends)
0:40-1:00Case studies: organizations at different maturity levels
1:00-1:20The transformation framework: where you are, where you need to be
1:20-1:50Hands-on: draft your transformation roadmap
1:50-2:00Commitments and next steps

Hands-On Exercise​

Goal: Draft a transformation roadmap for your organization.

The Maturity Spectrum:

Level 1: Vibe Coding          Level 2: Guided AI          Level 3: Governed AI
  "Just use Copilot"            "We have rules"             "We have enforcement"
  No governance                 AI tool configs              CI pipeline checks
  No audit trail                PR templates                 Quality gates
  No quality controls           Basic testing                Agent contracts
                                                             Metrics collection

Level 4: Managed AI            Level 5: Optimizing AI
  "We measure everything"        "AI improves our AI process"
  Full agent SDLC                Continuous improvement
  Monitoring stack               Self-healing governance
  Drift detection                Predictive quality metrics
  Incident automation            Cross-team learning

Exercise Steps:

  1. Place your organization on the maturity spectrum (be honest)
  2. Identify your target level at 6 weeks and 12 weeks
  3. Map the gap: what capabilities need to be added at each level
  4. Identify blockers: budget, culture, skills, tooling
  5. Draft a quarterly roadmap with specific milestones
  6. Define 3 leading indicators that will tell you if the transformation is working

Success criteria: A roadmap with current state assessment, target state, quarterly milestones, and leading indicators.

Discussion Framework​

The workshop uses a structured discussion format. Participants are guided through these questions:

  1. Where are we? Honest assessment of current AI coding practices, governance level, and pain points
  2. Where do we need to be? Target state based on risk profile, regulatory requirements, and competitive position
  3. What is blocking us? Common blockers: executive buy-in, developer resistance, budget, skills gap
  4. What is the first step? Identifying the highest-impact, lowest-friction starting point
  5. How will we know it is working? Defining measurable success criteria tied to business outcomes

Post-Workshop Resources​

Combining Workshops​

Workshops can be combined into multi-day events for broader coverage. Here are recommended combinations:

Leadership Day (4 hours)​

For executive and management audiences:

TimeWorkshop
Morning (2h)Workshop 8: From Vibe Coding to Agentic Engineering
Afternoon (2h)Workshop 2: AI Governance for CTOs

Outcome: Strategic understanding plus governance decision documented.

Technical Deep Dive (2 days)​

For engineering teams adopting AEEF:

DayTimeWorkshop
Day 1 AM30 minWorkshop 1: AEEF in 30 Minutes
Day 14hWorkshop 4: CI Pipeline Hardening
Day 14hWorkshop 3: Agent SDLC Deep Dive
Day 28hWorkshop 5: Multi-Agent Orchestration

Outcome: Full technical competency from Tier 1 through orchestration.

Governance Week (5 days)​

For organizations doing a full rollout:

DayWorkshopsAudience
MondayWorkshop 8 + Workshop 2Leadership
TuesdayWorkshop 1 + Workshop 7All engineers
WednesdayWorkshop 3 + Workshop 4Architects + DevOps
ThursdayWorkshop 5Senior engineers
FridayWorkshop 6Compliance + Security

Outcome: Entire organization trained with role-appropriate depth.

Workshop Delivery Guidelines​

For Self-Delivery​

All workshop materials are open source. To deliver a workshop within your organization:

  1. Clone the materials from the AEEF training repository
  2. Customize for your stack: Replace language-specific examples with your primary language
  3. Prepare the environment: Ensure all participants have Git, Docker, and required tools installed
  4. Time management: Keep lectures to 30% of time, hands-on to 70%
  5. Collect feedback: Use post-workshop surveys to improve future sessions
  6. Follow up: Schedule a 30-minute check-in 2 weeks after the workshop to assess adoption

For Instructor-Led Delivery​

Organizations that want a certified AEEF trainer to deliver workshops can:

  • Browse the trainer directory at aeef.ai
  • Request customized workshop content for their technology stack
  • Book on-site or virtual delivery
  • Combine workshops into multi-day programs

Participant Prerequisites Checklist​

Ensure all participants have the following before any technical workshop:

  • GitHub account with repository creation permissions
  • Git installed and configured
  • Docker installed and running
  • Text editor or IDE
  • Terminal access (bash or zsh)
  • Claude Code CLI installed (for workshops 5, 7)
  • Internet access for repository cloning and CI pipeline execution
Last updated on by BalrogEg