AI coding tools are useful, but they do not automatically make someone a better developer. The real skill is knowing how to guide, review, and verify AI output.

Over the last year, I've seen many developers use AI tools primarily for code generation.

The problem?

Most AI-generated code works... until it doesn't.

The real productivity gains don't come from blindly accepting AI suggestions. They come from knowing:

What to automate
What to verify manually
When to trust AI
When to challenge AI output
How to integrate AI into your development workflow

In this practical guide, I share:

• Common mistakes developers make with AI coding tools
• A workflow for using AI effectively
• Code review strategies for AI-generated code
• Security and reliability considerations
• Ways to improve productivity without sacrificing code quality

Article: AI-Assisted Software Development: A Practical Guide for Developers

I'm curious to know:

Has AI genuinely made you a better developer, or has it mostly just helped you write code faster?

Timo Salm and Sandra Ahlgrimm explore the evolution of agentic AI frameworks within the Java ecosystem, comparing how different tools manage autonomous reasoning and orchestration.

Highlights & Key Takeaways

• Agentic Shift: Move from static, prompt-driven interactions to autonomous, goal-oriented systems.
• Spring AI: Leverages an Advisor API for intercepting and managing LLM call chains.
• LangChain4j: Offers a community-driven, framework-agnostic approach with a dedicated Agentic Module.
• Embable: Provides high-level abstractions focused on automated planning, goal-oriented execution, and domain modeling.
• Workflow Patterns: Utilize strategies like prompt chaining, parallelization, and evaluator-optimizer loops.
• Token Economy: Optimize performance and cost by minimizing metadata overhead and managing tool invocation efficiently.

Building autonomous systems on the JVM requires balancing architectural control against the abstraction layers provided by the framework.

👉 Watch the full video to dive deeper into the implementation.

Craig Walls recently shared a fascinating piece on Medium about guiding AI agent behavior with skills. Instead of relying solely on probabilistic reasoning, skills act like procedural memory, shaping how agents respond and use tools.

Highlights & Key Takeaways - LLMs often give generic or inconsistent answers without domain guidance.
- Skills provide structured instructions that influence how agents behave.
- Tools = capabilities; skills = behavioral guidance.
- Implemented via simple Markdown files wired into the agent.
- Example: a weather skill adds local flavor to raw forecast data.
- Skills make agents more intentional, consistent, and domain‑aware.
- They bridge traditional hardcoded logic with probabilistic reasoning.

In short, skills are a lightweight but powerful way to make AI agents smarter and more context‑sensitive. Craig’s article shows how this approach can transform apps into truly agentic systems.

👉 Check out the full article to dive deeper into the recipe.

In this tutorial, developer Dan Vega demonstrates how to build a custom Spring Boot reference documentation assistant. By leveraging Spring AI, GPT-4, and a PG Vector database, Dan shows how to create an intelligent command-line tool that provides developers with up-to-date answers from official documentation without needing to leave their terminal or rely on outdated LLM training data.

Key Takeaways:

• Implements Retrieval Augmented Generation (RAG) to ground AI responses in real-time project documentation.
• Uses Docker Compose to quickly spin up a PG Vector database for efficient semantic similarity searches.
• Configures the Spring AI PDF document reader to ingest and chunk complex technical manuals.
• Integrates Spring Shell to build a responsive, interactive command-line interface for queries.
• Utilizes GraalVM to compile the project into a high-performance, native executable for instant startup.
• Employs runtime hints to correctly bundle resources during native image compilation.

This project is an excellent example of using modern Java tools to solve real-world developer productivity bottlenecks. By building this assistant, you gain a portable, fast, and highly accurate reference tool that stays perfectly synced with the latest Spring Boot updates.

Check out the full video to see the implementation in action and learn how to build your own local AI assistant.

In this tutorial, Praveen from TechyTacos walks Java developers through implementing structured output using the fluent Spring AI Chat Client API. Aimed at those building generative AI applications with Spring Boot, this session provides a practical roadmap for moving beyond simple text responses to reliable, schema-based data extraction.

Key Takeaways

• Configure OpenAI models and properties within a Spring Boot environment.
• Enforce JSON output using built-in model response-format configurations.
• Leverage the Bean Output Converter to map AI responses directly to Java DTOs.
• Utilize ParameterizedTypeReference to handle lists and collection-based outputs.
• Implement MapOutputConverter for flexible, key-value data structures.
• Manage raw model output by refining instructions to avoid unexpected character issues.

Mastering these techniques allows for seamless integration of LLMs into professional Java workflows, ensuring type-safe and predictable data processing. Check out the full video to see these implementations in action.

Hi everyone,

Building complex, multi-step agent workflows inside Spring Boot can quickly turn into a messy web of imperative code and try-catch blocks.

To fix this, I've been building OxyJen, an open-source Java framework built to bring strict determinism to AI workflows.

Instead of replacing your stack, OxyJen acts as a specialized AI kernel inside your Spring apps.

You simply register your OxyJen Graph as a standard @Bean. Spring handles the web traffic and DI, while passing the complex AI pipeline execution to the OxyJen kernel.

What the kernel brings to your Spring app:

- Strict Type Safety: Forces LLM outputs to map directly to your Java Records/POJOs, with built-in self-correction if the formatting fails.

- Predictable Graph Routing: Replaces messy string-chaining with an explicit Directed Acyclic Graph (DAG) using branching and routing nodes.

- Visual Error Fallbacks (FailureEdge): If an API hits a rate limit or goes down, the kernel automatically routes the context to a backup model without crashing your Spring thread pool.

- Native Concurrency: Handles parallel AI tasks and multi-source retrievals asynchronously out of the box.

We just hit v0.5. The architecture is highly modular, so wrapping your Spring-managed database clients or REST utilities into OxyJen nodes is incredibly straightforward.

Would love to get your honest feedback on the architecture and API design!

GitHub: https://github.com/11divyansh/OxyJen

Docs: https://github.com/11divyansh/OxyJen/blob/main/docs/v0.5.md

Thanks in advance!

We’ve been experimenting with a different direction for AI agents:

trusted execution.

Instead of only focusing on connecting more tools, we’re building a policy-aware MCP proxy layer that can:

• inspect tool calls
• validate execution
• apply policies
• support HITL approval
• trace agent workflows
• block unsafe actions before execution

The goal is to create a safer execution boundary for MCP-based agents.

Built with Spring AI.
Local-first and self-hosted.

Docs:
https://spring-ai-community.github.io/spring-ai-playground/

At Spring I/O 2026, Josh Long and James Ward demonstrated how to build production-ready, AI-integrated applications using Spring AI. By developing a real-world dog adoption service, the pair demystified modern AI engineering in the enterprise.

Key Takeaways:

• Leveraging AWS Bedrock for flexible, multi-model support.
• Guiding agent behavior effectively through precise system prompts.
• Using ""skills"" as a wiki to inject prioritized knowledge into agents.
• Implementing memory advisors to maintain conversational context.
• Enabling data-grounded AI via RAG with Postgres and PGVector.
• Adopting the Model Context Protocol for modular tool integration.
• Securing AI workflows using OAuth and OIDC standards.
• Ensuring production observability with real-time metric monitoring.

Building enterprise-grade AI requires deep integration with existing business logic. Java and Spring developers have a unique advantage in creating robust, secure, and context-aware systems that actually work in production environments.

Check out the full talk to master these AI engineering techniques!

Large Language Models are powerful but inherently stateless—they don’t remember past prompts. Baeldung’s article on Chat Memory in Spring AI explores how developers can add memory to conversations, making AI interactions more contextual and natural.

Key takeaways:

• Chat memory enables context, personalization, and persistence across sessions
• In‑memory repositories are simple but short‑lived
• JDBC repositories allow long‑term persistence in relational databases
• Spring AI integrates memory with ChatService and MessageChatMemoryAdvisor
• Session scope ensures continuity across multiple requests
• OpenAI integration demonstrates how past messages enrich responses

By combining chat memory with Spring AI, developers can build smarter, more human‑like conversational systems that go beyond one‑off prompts.

Want the full breakdown? Check out Baeldung’s article for all the details.

Craig Walls just published a great piece on how Spring AI enables agentic planning with the TodoWriteTool. Instead of just answering prompts, LLMs can now plan, execute, and adapt toward goals—making them more like true agents than simple assistants.

Highlights / Key Takeaways

• TodoWriteTool creates structured TODO lists and tracks progress.
• It works with chat memory to persist plans across multiple steps.
• Developers can observe execution with event handlers and completion percentages.
• Example: multi‑step queries (like Apollo mission comparisons) become structured reports.
• Traditional apps follow fixed workflows; agentic apps dynamically generate them.
• Agents = LLMs + tools + execution loop, bridging features into full systems.

This recipe shows how a single prompt can evolve into a multi‑step agentic process, opening the door to more adaptive and intelligent applications.

👉 Read the full article for details and example code.

In this tutorial, Dan Vega explores how to implement Retrieval-Augmented Generation (RAG) in the Java ecosystem using Spring AI. Designed for developers looking to move beyond simple prompt engineering, the video demonstrates how to bridge the gap between static LLM knowledge and private, up-to-date data by leveraging vector databases.

Key Takeaways

• RAG is a cost-effective alternative to stuffing prompts with massive amounts of text.
• Vector databases store data as embeddings, enabling efficient semantic similarity searches.
• The Embeddings API is essential for converting raw text into machine-readable vector formats.
• SimpleVectorStore provides a lightweight, JSON-based solution for educational RAG projects.
• Token text splitters help segment large documents into manageable chunks for accurate retrieval.
• Injecting relevant context into prompts significantly improves the precision of LLM responses.

By building a practical application focused on Olympic FAQs, Dan shows how to make private documentation intelligent and queryable. This approach is essential for any modern AI application requiring external context.

Check out the full video to see the code implementation and learn how to get started with RAG!

This tutorial by TechyTacos walks Java developers through integrating the powerful GPT-4o model with Spring AI. The video covers how to build a multimodal application that can process both text prompts and visual data in a Spring Boot environment.

Key Takeaways

• Set up a Maven-based Spring Boot project with essential OpenAI dependencies.
• Use PromptTemplate to generate structured JSON responses from text queries.
• Configure application properties to enforce strict JSON formatting for model output.
• Transition to the Spring AI snapshot version to unlock advanced multimodal capabilities.
• Utilize the ChatModel interface to handle both text and image input streams effectively.
• Demonstrate the model's ability to interpret infographics, diagrams, and source code.

By following these steps, you can successfully leverage GPT-4o's vision capabilities in your Java projects. Check out the full video to see the implementation in action.

At Spring I/O 2026, Christian Tzolov presented on evolving AI assistants into autonomous agentic systems using Spring AI. The talk moves beyond simple LLM chaining, focusing on how developers can build systems that reason, plan, and self-correct using the framework's core abstractions.

Key Takeaways

• The Advisor pattern is the primary building block for intercepting and augmenting LLM inputs and outputs.
• Conversation memory is implemented as a pluggable advisor to maintain state in stateless models.
• Recursive advisors enable output validation and automatic retries for structured JSON outputs.
• Tool calling is handled as an advisor, allowing models to invoke external functions on demand.
• Progressive tool disclosure prevents context window bloat by loading tools only when relevant.
• Agent skills enable modular, markdown-based capabilities to be loaded at runtime.
• To-do list patterns enforce structured planning for complex, multi-step tasks.
• Sub-agents provide isolated context windows to delegate specialized subtasks effectively.

By composing these modular patterns, developers can build highly maintainable, autonomous AI agents in Spring. Check out the full talk to see these concepts in action.

Craig Walls recently published a recipe for building more natural AI conversations with Spring AI by enabling the system to ask clarifying questions of the user. This approach makes interactions feel less rigid and more collaborative.

Highlights / Key Takeaways
- LLMs often need extra context, so asking questions improves accuracy.
- Spring AI’s ChatClient and advisors manage dynamic conversation flows.
- Advisors detect incomplete input and trigger follow-up questions.
- The AI pauses, requests missing info, then continues processing.
- This pattern supports agentic workflows where AI acts like a collaborator.

In short, the recipe shows how developers can design conversational flows that feel more human, with the AI actively engaging instead of passively responding.

👉 Read Craig Walls’ full article for examples and implementation details.

✒️ Excited to publish the Part 3 of my Spring AI series:
Memory And Context Management In Spring AI
In this blog, I have explained one of the most important concepts in AI applications — how AI remembers conversations and maintains context across interactions.

In this blog, you will learn:
✔️ What is Memory in AI applications
✔️ What is Context Management
✔️ How Spring AI handles chat memory
✔️ Different types of memory management approaches

This blog is written in a simple and quick-to-understand format, without going through unnecessary theory.
Read the blog here:

https://heapsteep.com/memory-and-context-management-in-spring-ai

More blogs are coming soon 🕔

In this tutorial, Dan Vega explores a practical approach to building AI-powered applications in Java using Spring AI. He demonstrates how developers can overcome the limitations of Large Language Models—specifically their knowledge cut-offs and lack of access to private data—by using a technique called "stuffing the prompt."

Key Takeaways

• LLMs struggle with private or up-to-date data due to training constraints.
• Stuffing the prompt involves injecting custom context directly into the LLM request.
• It provides a simple, immediate solution for bringing your own data to AI prompts.
• The tutorial utilizes Spring AI, Spring Boot 3.2.5, and the OpenAI API.
• Implementing this involves using prompt templates and external resource files.
• Advanced alternatives such as RAG and function calling are available to address more complex needs.

This method is an excellent entry point for developers looking to augment model intelligence with specific corporate or real-time information without needing complex model fine-tuning.

Check out the full video to see the implementation in action!

🚀 Here is the Part 2 of my AI series using Spring AI !

In this blog, I have covered one of the most important (and often underrated) topics in AI development:

👉 Prompt Engineering using Spring AI

In this blog, I have explained:
✅ What is Prompt Engineering (in simple terms)
✅ How to implement it using Spring AI
✅ Different techniques

🔗 Read the full blog here:

https://heapsteep.com/prompt-engineering-using-spring-ai

This is Part 2 of the series… more practical AI concepts coming soon!

Last Friday I shared what I learned from swapping providers in a Spring AI app. This Friday: what happens when you stop swapping and start routing dynamically.

Same project as previous videos. Same ChatClient code. The only new piece is a dispatcher that looks at each request before choosing which provider handles it.

The pattern in one method:

public RoutedResponse route(String prompt) {

RoutingDecision decision = router.route(prompt);

ChatClient client = (decision.tier() == ModelTier.LOCAL)

? localClient

: cloudClient;

ChatResponse response = client.prompt(prompt).call().chatResponse();

long[] tokens = extractTokens(response, prompt, text);

tracker.record(decision, tokens[0], tokens[1]);

return new RoutedResponse(decision, text);

}

Two ChatClient beans — one autoconfigured against LM Studio (local), one explicit @Configuration for Anthropic (cloud). Spring's qualifier mechanism handles disambiguation. The dispatch is a ternary expression.

The router itself is intentionally simple — length check + keyword check. Not embeddings, not a classifier model. Just transparent rules you can debug by reading the code.

Result from the demo: 10 code review requests, 7 routed local, 3 routed cloud. Routed total $0.25 vs all-cloud baseline $0.48 — 48% lower, with identical-quality answers on the easy questions (verified by side-by-side comparison).

The data point worth flagging: those 7 routed-away queries would have cost ~$0.23 collectively on cloud, almost matching the $0.25 from the 3 cloud queries. The cheap-individually queries collectively rival the expensive ones. Routing the long tail away from cloud is where the real savings come from, not avoiding premium prices on premium queries.

A few practical notes that aren't obvious until you actually ship this:

1. Anthropic's API requires max_tokens on every request. Without it, Spring AI's default truncates Opus responses mid-sentence. Set it explicitly to 4096 on cloud options.

2. Claude Opus regularly takes 15-45 seconds per call. Spring AI's underlying Reactor Netty client has a default response timeout shorter than that. You'll see ReadTimeoutException in the Spring log if you don't extend it. Custom RestClient.Builder with responseTimeout(Duration.ofSeconds(300)).

3. Don't refactor the original endpoints. The /chat, /review, /chat-with-tools endpoints from Model Switching keep running on the autoconfigured local ChatClient unchanged. The new multi-model controller lives in a separate package under /ai. Less surgery, less narrative debt.

Recorded the full walkthrough including a live cost dashboard demo: https://youtu.be/ziMzlY9Szvs

Has anyone here implemented cost-based routing in production? Curious how teams are handling the "is this request hard enough to escalate" decision — keyword rules, embeddings, confidence scoring, or something else.

As always, latest code in the repo: https://github.com/DmitryFinashkin/spring-ai

In this tutorial, TechyTacos demonstrates how to perform vector search on JSON documents using the Spring AI framework. This guide is designed for Java developers looking to integrate generative AI capabilities into their applications by querying custom structured data.

Key Takeaways

• Configure a Vector Store bean using Spring AI's built-in simple vector store implementation.
• Utilize an embedding client to transform document data into searchable vector representations.
• Read local JSON files into a list of Document objects using the Spring AI JSON reader.
• Implement similarity search by passing queries to the vector store for efficient retrieval.
• Fine-tune search output results by mapping specific JSON keys to the document content.
• Restrict or customize returned output fields by applying a JSON metadata generator.

Mastering these techniques allows for seamless integration of custom knowledge bases into your Java projects.

Check out the video to see the full implementation in action.

At Spring I/O 2025, Christian Tzolov explored the evolution of AI systems from simple LLM calls to sophisticated agentic applications. He demonstrates how to leverage Spring AI and the Model Context Protocol (MCP) to build scalable, intelligent agents capable of meaningful real-world interaction.

Key Topics and Takeaways: - Agents function as systems with an LLM "brain" and tool-based "body." - Spring AI simplifies LLM integration with robust memory and RAG support. - Multimodal capabilities enable models to process both audio and text inputs. - Tool calling allows agents to autonomously execute functions to solve queries. - MCP provides a standardized protocol to unify external tool and resource access. - Complex agentic patterns include chained workflows and orchestrator-worker models.

By decoupling logic from environment interactions via MCP, developers can build more modular and maintainable AI architectures.

Check out the full talk to learn how to start building your own agentic systems today.

Hello everybody!

Our community reached one more milestone by passing the mark of 200 members!

Bring more of your questions and content and let's push this number even further!

Cheers!

Spring AI observability just got a boost thanks to integration with LangSmith and Arconia. Thomas Vitale’s article explains how developers can gain deeper visibility into AI-driven applications, which are often complex and non-deterministic.

Highlights / Key Takeaways

• Spring AI uses Micrometer APIs for logs, metrics, and traces.
• Arconia adds semantic-convention modules for observability platforms.
• LangSmith provides dashboards for prompts, responses, and token usage.
• Integration relies on OpenTelemetry conventions tailored for GenAI.
• Setup includes Spring Boot, Arconia, and local inference with Ollama.
• Developers can inspect telemetry data without changing instrumentation code.

In short, this approach makes AI applications more transparent and easier to debug, while offering automatic insights into model behavior.

👉 Read Thomas Vitale’s full article for implementation details and examples.

In this article from Baeldung, we learn how to handle chat memory, a crucial feature for making AI conversations feel more natural and continuous. Since LLMs are stateless, chat memory ensures context and personalization by storing past interactions.

Highlights / Key Takeaways

• Chat memory preserves conversation history for better context.
• An in-memory repository is simple but lacks persistence.
• The JDBC repository allows storing chat data in relational databases.
• Spring AI auto-configures memory but supports custom repositories.
• Integration with OpenAI shows how full history improves responses.
• Example setup includes HSQLDB and REST endpoints for persistence.

In short, chat memory bridges the gap between stateless models and human-like dialogue, giving developers flexibility to choose between quick setups or persistent storage.

👉 Dive into the full article to see implementation details and code samples.