Agile Engineering

ICAgile Certified Professional - Agile Engineering (ICP-PRG)

Master the technical engineering practices that make agile teams consistently

Description

Agile teams that adopt the right engineering practices consistently outperform those that rely on process alone. This two-day course teaches the technical disciplines that enable teams to maintain high velocity without sacrificing quality: test-driven development, clean code, emergent design, continuous integration, and collaborative engineering practices.

Participants work through real code examples and hands-on exercises throughout both days. The course is structured to build skills progressively, starting with the TDD mindset and unit testing fundamentals, moving through acceptance tests and BDD collaboration, and then into code quality, design, and delivery pipeline practices.

Key takeaways from this class include:

Applying the red-green-refactor cycle of TDD with confidence on working code.
Writing clear acceptance tests using ATDD and BDD techniques to align teams around shared examples.
Identifying and removing code smells through disciplined, safe refactoring.
Applying SOLID principles and simple design rules to reduce coupling and improve maintainability.
Setting up and working within a continuous integration pipeline with automated quality gates.
Understanding continuous delivery practices that reduce deployment risk and increase release confidence.
Using pair programming, code review, and collective ownership to raise team-wide code quality.

Who Should Attend

This course is for software engineers, developers, test engineers, and technical leads who work in agile teams and want to build or sharpen the technical practices that make agile delivery sustainable. It is also useful for QA professionals who collaborate closely with developers on automated testing and quality strategy.

Course Structure

Agile Engineering course consisting of lecture, demonstration, and hands-on exercises. Participants are expected to write and modify code during exercises; a basic working knowledge of at least one programming language is recommended.

Course Completion and Certification

Successful attendees of this course are awarded the ICAgile Certified Professional - Agile Engineering (ICP-AE) designation. Additionally, certified attendees are listed on the ICAgile website to indicate their designation. Coveros recommends Agile Fundamentals - ICAgile Certified Professional (ICP) for those seeking the full ICAgile Agile Engineering certification path. The ICAgile certification fee is included with your registration for your convenience.

Preparation

Attendees should have working experience with at least one programming language and some familiarity with agile delivery practices. Prior completion of Fundamentals of Agile (ICP) or equivalent experience is recommended.

About the ICAgile

The International Consortium for Agile's goal is to foster thinking and learning around agile methods, skills, and tools. ICAgile, working with experts and organizations across agile development specialties, has captured specific learning objectives for different agile development paths and placed them on the learning roadmap. For more information, visit www.icagile.com.

Course Duration and Schedule

Two-Day Format

8:30 AM - 4:30 PM each day with a 1-hour lunch break and morning and afternoon breaks.

Three-Day Format

11:30 AM - 5:00 PM each day with afternoon breaks.

Upcoming Training

There are currently no scheduled classes for this course. If you would like to request one, click here for more information.

Request a Class

Course Outline

Session 1: Agile Engineering Mindset and Principles

The engineering challenges agile teams face
Why technical practices are inseparable from agile values
Technical debt: causes, costs, and consequences
The role of the engineer on a cross-functional agile team
Engineering practices in Scrum, XP, and SAFe contexts
Sustainable pace and the importance of built-in quality
Overview of the XP engineering practices

Session 2: Test-Driven Development (TDD)

What TDD is and why it matters
The red-green-refactor cycle
The three rules of TDD
Writing good unit tests: isolation, speed, and clarity
Test doubles: mocks, stubs, spies, and fakes
Code coverage concepts and their limits
Common TDD mistakes and how to avoid them
TDD exercise: applying the cycle on a working example

Session 3: Acceptance Test-Driven Development (ATDD) and BDD

From unit tests to acceptance tests
The ATDD cycle: discuss, distill, develop, demonstrate
Writing acceptance criteria as executable specifications
Introduction to Behavior-Driven Development (BDD)
The Given-When-Then structure for scenarios
Collaboration between product owners, testers, and developers
Feature files, step definitions, and automation frameworks
ATDD/BDD exercise: defining and automating a feature

Session 4: Clean Code and Refactoring

What clean code means and why it is an engineering discipline
Naming, functions, comments, and formatting conventions
Code smells: recognizing and categorizing problematic patterns
The refactoring process: small, safe, tested changes
Key refactoring techniques: extract method, rename, replace conditional, move field
Using IDE refactoring support safely
Refactoring legacy code without full test coverage
Refactoring exercise: improving an existing code base

Session 5: Emergent Design and SOLID Principles

What emergent design means in an agile context
Simple design: the four rules of simple design
SOLID principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
Common design patterns that support agile code
Designing for testability
Avoiding over-engineering and premature abstraction
Design exercise: applying SOLID to an existing example

Session 6: Continuous Integration

The goal and philosophy of continuous integration
CI vs. traditional integration approaches
Commit frequency and trunk-based development
Anatomy of a CI pipeline: compile, unit test, static analysis, package
Build failure as a team event: stopping the line
Automated code quality and coverage gates
CI tooling landscape overview
CI exercise: walking through a sample pipeline

Session 7: Continuous Delivery and Deployment Automation

The difference between continuous delivery and continuous deployment
The deployment pipeline: from commit to production
Environment consistency and infrastructure as code
Test stages in the pipeline: integration, acceptance, performance, security
Feature flags and deployment risk reduction
Monitoring and fast feedback from production
Measuring delivery performance: lead time, deployment frequency, MTTR, change failure rate

Session 8: Collaborative Engineering Practices and Wrap Up

Pair programming: styles, benefits, and practical tips
Mob programming and ensemble working
Code reviews: goals, techniques, and useful feedback
The collective code ownership principle
Continuous learning habits for engineering teams
Building a personal improvement plan
Wrap-up discussion: applying practices back at work
Course evaluation and next steps