Agentic Software Engineering Training

Generative AI is changing how we build software – from individual code completions to fully agent-driven development workflows. In this three-day hands-on training, Agentic Software Engineering, you and your team will learn how to ship faster with AI agents across the entire engineering lifecycle – without sacrificing quality, control, or accountability.

Focus: Agentic Engineering

You’ll learn how to deploy AI assistants and autonomous agents effectively across the full engineering lifecycle: from AI-assisted requirements and product work, through automated architecture design, to autonomous code agents that implement complex features, write tests, and maintain pipelines. You’ll stay in control throughout – and you’ll learn where human expertise remains essential.

What You’ll Take Away

After the training, you will:

• understand the technical foundations of LLMs, context, tool use, MCP, and agent feedback loops.
• use AI agents across everyday software development tasks without abandoning proven engineering practices.
• know how to produce and validate requirements, architecture decisions, documentation, code, tests, and pipelines with agent support.
• have a realistic sense of where agents genuinely accelerate the work – and where review, guardrails, and human judgment are still essential.
• leave with a shared vocabulary and practical starting points for applying these techniques in your own projects.

Who Is This Training For?

This training is for anyone who wants to use generative AI in software development in a systematic, practical way:

• Software developers who want to integrate AI agents into their day-to-day work.
• Tech leads, architects, and senior engineers who want to evaluate or roll out agents for planning, architecture, review, and quality assurance.
• DevOps and platform engineers who want to bring AI into CI/CD, automation, infrastructure as code, and operations.
• Product managers and other engineering-adjacent roles who want to understand how AI agents influence requirements, documentation, and implementation planning.

We recommend you bring practical development experience, basic Git familiarity, and a willingness to work hands-on with development tools.

Hands-On: How the Training Works

The training is designed as an end-to-end workshop – not a lecture, but hands-on work on a realistic software project.

• You’ll work in a prepared exercise repository with reproducible starting states and exercises that build on each other.
• The exercises take you from product and requirements artifacts through architecture and implementation planning to tests, CI/CD, and agent-driven repository workflows.
• Your outputs are concrete project artifacts, not just chat transcripts: documentation, backlog items, architecture decision records (ADRs), code changes, tests, pull requests, pipeline configurations, and issues.
• We deliberately train for reviewability and validation: agent outputs get checked, refined, and broken down into smaller, traceable units.
• You’ll experience both productive use cases and intentionally risky approaches, so you can see where the limits are and what guardrails you need.

We alternate short concept introductions, live demos, and hands-on exercises throughout. Built-in reflection and discussion time helps you weigh the benefits, risks, and organizational implications.

Agenda

1. Foundations of AI Agents
   • Foundation models, large language models, and autoregressive text generation
   • Context, memory, and the importance of high-quality input data
   • Tool use, the Model Context Protocol (MCP), and agent harnesses
   • Differences between assistants and agents: agents observe, act, and change system state
   • Overview of the current agent landscape and common tool categories
2. Requirements and Product Development
   • Using AI throughout the product development cycle
   • Creating and maintaining glossaries, proto-personas, user journeys, user story maps, epics, and user stories
   • Prompting techniques for structured, reusable results
   • Building a consistent backlog from existing product documentation
   • Agent-supported prototypes for rapid validation of product ideas
3. Architecture and Technical Decisions
   • Deriving and documenting quality requirements using quality scenarios
   • Applying proven architecture methods and quality models with AI support
   • Structured architecture decisions, including options, trade-offs, and ADRs
   • Maintaining architecture documentation, system contexts, building block views, and technical debt
   • Validating agent outputs as a core part of architecture work
4. Implementation with Agents
   • Context management as a prerequisite for larger, more reliable agent tasks
   • Agent setup with memory, rules, commands, skills, subagents, IDE integrations, and hooks
   • Distinguishing experimental vibe coding from production-grade software engineering
   • Spec-driven development, planning mode, task breakdown, and reviewable units of work
   • Agents as coding buddies for features, refactoring, debugging, library usage, Git workflows, pull requests, and reviews
   • Parallelizing development work with multiple agents and separate working contexts
5. Testing and Quality Assurance
   • Generating and improving unit, integration, and end-to-end tests
   • Identifying untested edge cases and gaps in existing test suites
   • UI interpretation and browser automation for realistic end-to-end scenarios
   • Reviewing merge requests, iterating on findings, and evaluating agent-generated changes
   • Detecting quality and security risks with agent support
6. CI/CD and Automation
   • Using AI agents to support CI/CD strategies and pipeline design
   • Creating and optimizing scripts, workflows, and repeatable automation steps
   • Test and build automation, including reporting and containerization
   • Agents as pipeline jobs for release notes, reviews, or flagging untested edge cases
   • Working with infrastructure as code and migrating between IaC formats
7. Operations and Monitoring
   • Using agents for logging, metrics, dashboards, alerts, and proprietary query languages
   • Integrating agents with operations and monitoring tools
   • Analyzing logs, alerts, database queries, and tracing data for error and performance diagnostics
   • Agent-supported suggestions for bug fixes and performance optimizations
   • Necessary guardrails for automated changes in production

If you have questions about Agentic Software Engineering or want to learn more, reach out to Theo Pack, Principal Consultant at INNOQ.