Agentic Software Engineering Voeg toe aan favorieten

Introduction
AI is no longer just an autocomplete tool. Modern AI systems can plan work, decompose tasks and generate working code, marking the shift toward agentic development and fundamentally changing what software development looks like and what the role of a developer becomes.

Detailed description
AI is rapidly changing the way software is built. Modern AI systems can plan work, break down complex tasks, call external tools, and generate working code within a single workflow. This fundamentally shifts what software development looks like and what makes a developer effective.

This training starts by tracing the evolution of AI: from early rule-based approaches, through the deep learning breakthroughs of the 2010s, through the augmentation era of tools like GitHub Copilot and chat assistants, and into the current agentic era where AI systems plan, act, and self-correct.

Rather than focusing only on tools, we examine how the nature of software development itself is changing. The primary bottleneck is no longer writing code. It has shifted toward clearly specifying problems, reviewing generated output, and integrating solutions into larger systems.

This shifts the role of the developer. Instead of focusing mainly on writing code line by line, developers increasingly act as directors of the development process, defining problems, guiding AI systems, and ensuring that generated solutions meet quality and architectural requirements.

Day 1 focuses on building an effective personal engineering workflow with AI. Participants learn the do’s and don’ts of working with AI agents, apply spec-driven development to get consistent and high-quality output, and explore how AI can make you more effective beyond software engineering as well. We also cover sub-agents, team agents, skills, and how to continuously improve your workflow over time.

An important part of this transition is understanding the limits of AI. High-velocity code generation without careful review introduces real risks. During the training we discuss how to recognise what AI systems structurally miss, how to create strong feedback loops, and how to introduce guardrails that maintain quality beyond traditional code review.

The second day shifts to deeper technical integration. Participants work hands-on with local model deployment, RAG (Retrieval-Augmented Generation) systems, tool calling, the Model Context Protocol (MCP), multi-agent workflows, and evaluation and observability techniques for AI-enhanced Java applications.

Prerequisites
Solid Java development experience and familiarity with REST APIs and modern frameworks. Some experience with GitHub and modern IDEs is helpful. No prior AI experience required. We will build that foundation together.

Participants are expected to have access at least one of the following tools for the hands-on portions of both days:

• IntelliJ with AI agent subscription
• OpenAI account
• Anthropic account
• Google Gemini account
• GitHub Copilot

Target audience
Designed for Java developers, architects, and tech leads who recognise that AI is transforming both how we build software and what we can build. Whether you are exploring AI capabilities, planning AI features for your applications, or leading teams that need to adopt AI tools effectively, this training gives you practical expertise that is immediately applicable.

Learning goals
After completing this training, participants will be able to:

Understand how AI has evolved from rule-based systems to modern agentic workflows
Understand how AI is changing the developer’s role from writing code to specifying, reviewing, and integrating solutions
Apply the do’s and don’ts of working effectively with AI agents
Build and implement their own AI-powered engineering workflow
Apply spec-driven development to get consistent, high-quality output from AI systems
Apply basic guardrails to keep AI-generated output reliable
Work with sub-agents, team agents, and skills to extend AI agent behaviour
Continuously improve their personal AI workflow through self-learning
Apply AI effectively beyond software engineering tasks
Deploy and query local language models using Ollama and vLLM
Build RAG systems in Java using LangChain4j and vector databases
Implement tool calling and connect AI systems to real-world data and services
Build and consume MCP servers with Spring AI and LangChain4j
Design and orchestrate multi-agent workflows using sequential, parallel, loop, and conditional patterns
Evaluate and observe AI system behaviour in production using OpenTelemetry and LLM engineering platforms

Topics covered
Understanding the evolution of AI assisted software development and the rise of agentic workflows
Do’s and don’ts of effectively using AI agents
Implementing your own effective engineering workflow with AI
Spec-driven development
Basic guardrails
Sub-agents, team agents, and skills
Self-learning and improving your workflow
Other ways outside of software engineering to use AI more effectively
Local model deployment with Ollama and vLLM
Building RAG systems in Java
Tool calling and connecting AI to real-world systems
Model Context Protocol (MCP) with Spring AI and LangChain4j
Multi-agent workflows and orchestration patterns
Evaluation and observability with OpenTelemetry

Training outline
Day 1: AI-Accelerated Development

The evolution of AI in software engineering: from automation to the agentic era
The fundamental shift: how AI changes the developer’s role
Do’s and don’ts of working with AI agents
Building your own effective AI-powered engineering workflow
Spec-driven development: structured specifications for consistent AI output
Basic guardrails and the LGTM trap
Hands-on with OpenCode and OpenSpec
Sub-agents, team agents, and skills
Using AI effectively outside of software engineering
Build your own fully automated and Self-improving workflow.
Day 2: AI Integration for Java Applications

Local model deployment with Ollama and vLLM (2 hours)
Building RAG systems with Java and LangChain4j (2 hours)
Tool calling: connecting AI to real-world systems (2 hours)
Model Context Protocol (MCP) with Spring AI and LangChain4j (2 hours)
Multi-agent workflows: sequential, parallel, loop, and conditional patterns (2 hours)
Evaluation and observability with OpenTelemetry and LLM engineering platforms (1-2 hours)

Course format
This is an in-person classroom training that can be delivered at an OpenValue office or as an in-company training.

Certification
Participants receive a certificate of completion upon finishing the training.

Next steps
For more information about expanding your knowledge past this course, check out our entire training portfolio at www.openvalue.training or in your learning management system. Contact us at trainingopenvalue.nl for personal learning advice or customized on-demand training and just contact your OpenValue trainer during the training course.

Provided training material
Learning material with slides and exercises will be available for the participants.

About the trainers
Tom Wigleven is Principal Engineer at OpenValue. Mauro Palsgraaf is Senior Software Developer at OpenValue.