Automating Java Development with AI

AI is reshaping software development — evolving from basic code suggestions to intelligent agents that can understand, plan, generate, and verify entire features. This hands-on, project-based course teaches you how to build and evolve real-world Java/Spring Boot applications in close collaboration with powerful AI tools like ChatGPT, Cursor, and GitHub Copilot.

You’ll begin by understanding the core principles of large language models (LLMs) — how they generate code, their strengths and limitations, and how to prompt them effectively. You’ll also learn how to work safely and reliably with AI, avoiding hallucinations, guiding its reasoning, and verifying its output.

A key part of the course is building a structured, reusable Knowledge Base that serves as a shared understanding between humans and AI. You’ll document requirements, define actors and use cases, and iteratively refine specs to align your project’s design with its goals.

Throughout the course, you’ll learn to:

• Clarify requirements and generate UML diagrams using AI-assisted knowledge modeling.
• Design complete domain models, repositories, and service logic with Spring Boot, JPA, and Lombok—automatically.
• Build clean REST APIs with AI-generated controllers, request validation, and OpenAPI docs.
• Automate the creation of unit, integration, and HTTP flow tests to continuously validate functionality.
• Refactor and evolve your codebase as requirements change, using AI for safe updates and consistency.
• Configure a workflow-driven AI pipeline, chaining reusable prompt patterns to automate your entire dev loop.

By the end, you’ll have built a maintainable, production-ready Spring Boot app—with AI as your coding partner. More importantly, you’ll master the skills to prompt, guide, and collaborate with AI tools across any future project.

By the end of this course, participants will be able to:

• Leverage large language models (LLMs) to clarify business requirements and construct structured knowledge bases, including user stories, actors, interaction flows, and UML diagrams.
• Design and refine domain models using AI tools, generating JPA entity classes, relationships, and Spring Data repositories with validation and consistency checks.
• Prototype and validate application logic by generating AI-powered CLI interfaces aligned with functional specifications.
• Build full-stack Spring Boot applications using AI-assisted generation of service layers, REST controllers, and API contracts following clean architecture principles.
• Use prompt patterns to automate development workflows, including clarification, planning, coding, testing, and code review.
• Automatically generate and execute unit, integration, and end-to-end tests, including .http flow tests for REST APIs.
• Generate and maintain OpenAPI documentation based on AI-generated controllers and DTOs.
• Adapt and refactor applications in response to changing requirements, using AI for safe modifications, code reviews, and consistency verification.
• Configure and apply workflow-driven automation using pattern chaining and IDE-based orchestration (Cursor) to streamline repetitive development tasks.

Module 1 • Foundations of AI-Driven Java Development (7h)

1. Introduction

– Introduction, trainer profile, learner poll, company AI-usage disclaimer

2. Large Language Models (LLMs) for Coding

• Neural-network basics (perceptron, gradient descent, learning)
• 2017 Transformer breakthrough, attention & vector embeddings
• LLM training and Reinforcement Learning
• Context, context window limits & stateless dialogs
• LLM temperature, randomness
• Reasoning models (Chain-of-Thought, planners)
• Knowledge Cutoff
• AI Tools in Chat interface (web search, file analysis, etc.)

3. Specialized IDEs for developers

– Chat interfaces vs IDE plugins; GitHub Copilot vs Cursor & other agents

4. Working Effectively with AI

– Context gathering, Cursor modes, RAG in Cursor, explicit @-references, iterative dialogue & verification

5. Prompt Engineering and Prompting Techniques

– Role Playing, Step-by-Step Reasoning, Providing Examples, Contextual Anchoring, Iterative Refinement, Constraints and Requirements, Asking for Explanations, Asking for Alternatives.

6. Risks & Limitations

– Hallucinations, “vibe coding”, autonomous-agent/YOLO dangers and mitigation strategies

7. Live Demonstration (Cursor)

– Good vs bad prompts, adding context, first edits, .cursorrules influence

Module 2. Prompt Patterns & AI-Assisted Workflow for Java/Spring applications (4h)

1. The Repetition Problem & Pattern Solution

– From sticky-note prompts to reusable @-files

2. Core Pattern Library

• @ask (clarify) - @plan (steps) - @create-unit-test / @create-integration-test / @create-http-test
• @test (run) - @ijhttp (flow tests) - @code-review

3. End-to-End Development Flow with Patterns

• Scaffold Spring Boot project (AI + Initializr)
• Clarify requirements (@ask)
•  Approve plan (@plan)
• Implement code
• Generate & execute tests (@create-*, @test, @ijhttp)
•  AI-driven code review & iterative fixes

4. HTTP Flow Testing (.http scripts)

5. Best-Practice Pattern Usage & Summary

Module 3. Building a Project Knowledge Base with AI (4h)

1. Why do we need a Knowledge Base?

– Turning vague ideas into structured, persistent context (docs/…)

2. AI as Business Analyst Assistant

3. Recommended Knowledge Base Structure

– requirements.md, actors.md, glossary.md, user_stories.md, use_cases.puml, cli-spec.md, …

4. Documentation-Focused Patterns

• @req, @actors, @stories, @use_cases, @glossary
• @cli-spec, @cli-spec-review, @ambiguity, @alt, @merge, @improve, @simplify

5. Workflow: From Idea to Prototype

Idea → clarify → actors → stories → UML diagram → CLI prototype → reviews & merges

6. Context Hygiene & Safety Tools

– New-chat discipline, Restore Checkpoint, Cmd-K precise edits

7. Hands-On Exercise

– Build KB for a sample domain (library, bank, airport…) using every pattern once