DEV Community: Ved Sharma

Lets create no cost personal coding assistant alternative to Claude code/Cursor

Ved Sharma — Tue, 10 Feb 2026 08:14:18 +0000

Orchestrating Semi-Autonomous Agentic Workflows: A Technical Framework for Integrating Cline, n8n, and the Model Context Protocol

The transition from static code completion to dynamic, semi-autonomous agentic systems represents the current frontier in software engineering productivity. While traditional large language models (LLMs) operate with significant internal reasoning capabilities, their utility is fundamentally constrained by the “sandbox” of their training data and the isolation of their execution environment. To transcend these limitations, an architecture must be established that bridges high-level reasoning with real-world tool execution. The integration of Cline, an advanced interface for Visual Studio Code, with n8n, a comprehensive workflow automation platform, provides this necessary infrastructure. By utilizing the Model Context Protocol (MCP) as a standardized communication layer, developers can construct a system where the “hard work” of environmental interaction — such as searching global package registries, executing multi-language test suites, and performing live internet research — is offloaded to a deterministic automation engine while leaving the sophisticated code generation and structural reasoning to the agentic core.1

Architectural Overview of the Semi-Autonomous Ecosystem

The proposed ecosystem functions as a distributed intelligence network where components are categorized by their role in the decision-execution cycle. Cline serves as the primary orchestrator, maintaining the state of the local codebase and acting as the human-facing interface within the Integrated Development Environment (IDE). n8n serves as the external nervous system, capable of reaching out to APIs, registries, and the underlying host operating system to perform tasks that would be computationally expensive or contextually impossible for a standalone LLM to perform reliably.3 The Model Context Protocol (MCP) serves as the bridge, ensuring that these two distinct systems can share tools and data schemas without the need for bespoke, fragile integration code.1

To satisfy the operational requirements of a modern development environment, this system must fulfill seven core functional pillars.

Functional Requirements (The 7 Pillars)

A professional-grade semi-autonomous agent must satisfy these core requirements to be effective in a production environment :

1. Internet Search: Query GitHub, StackOverflow, and blogs for real-time documentation and bug fixes.

2. Registry Discovery: Interact with Pub.dev (Flutter), npm (Node.js), Maven (Java), NuGet (.NET), Docker Hub, and Helm.

3. Safe Multi-File Modification: Inject imports, update cross-file logic, and refactor without losing project context.

4. Language-Specific Validation: Execute native test runners like mvn test, npm test, or flutter test to ensure code integrity.

5. Human-in-the-Loop (HITL) Approval: Require explicit developer consent for high-impact terminal commands or file writes.

6. Multi-LanguageEcosystem Support: Detect the active stack and adjust search/validation strategies automatically.

7. Dynamic Intelligence Switching: Toggle between zero-cost local models and high-reasoning paid cloud APIs based on task difficulty.

Core Component Requirements and Comparative Analysis

The selection of tools for this ecosystem is predicated on their ability to interoperate via open standards. The following table identifies the requisite components and their specific roles within the semi-autonomous framework.

Interactive Installation and Environment Baseline

The establishment of a hands-on environment begins with the local infrastructure. For the agent to function without constant reliance on external cloud services, a local inference engine is indispensable. Ollama is the preferred solution for this requirement, providing a standardized API that mimics cloud providers while running entirely on local hardware.5

Step 1: Deploying the Local Inference Engine

Installation of Ollama is the first prerequisite. For macOS and Linux users, a simple shell command initiates the process, while Windows users utilize a traditional installer.5 Once installed, the primary task is to fetch a model optimized for coding. The codellama:13b-instruct or llama3 models are frequently cited as the baseline for local reasoning.5

Interactive Command Sequence for Ollama:

Execute curl -fsSL https://ollama.com/install.sh | sh to install the backend.2
Execute ollama pull codellama:13b-instruct to download the specific weights for the coding agent.
Verify the service is operational by querying the local endpoint: curl http://localhost:11434/api/tags.

The availability of a local model ensures that the agent can perform routine tasks — such as boilerplate generation or simple refactoring — without incurring API costs or transmitting sensitive codebase details to external servers.14

Step 2: Orchestration Layer Deployment with n8n

The deployment of n8n must be approached with the understanding that it will act as the primary interface for “hard work” tasks.2 Running n8n via Docker is recommended because it allows the “Execute Command” node to run within a controlled, containerized environment, which is vital for multi-language testing.6

To initialize n8n with the necessary persistence, a dedicated Docker volume must be created. This ensures that the workflows and credentials configured during the setup are not lost upon container restart.16

Bash (Assuming you have some familarity with Docker)

docker volume create n8n_data
docker run -it — rm — name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n n8nio/n8n

Upon successful startup, the user navigates to http://localhost:5678 to finalize the account setup. It is critical to note that n8n Cloud is a viable alternative for users who do not wish to manage infrastructure, although some “Execute Command” capabilities are restricted on the cloud tier.6

Step 3: Installing and Configuring Cline in VS Code

Cline is the final piece of the local installation. It is acquired through the Visual Studio Code Extension Marketplace. After installation, the user must navigate to the settings gear (⚙️) within the Cline panel to establish the connection to the Ollama backend.18

Key Configuration Settings for Cline:

API Provider: Select “Ollama” from the dropdown menu.14
Base URL: Ensure it points to http://localhost:11434.14
Model ID: Select the codellama:13b-instruct model downloaded in Step 1.14
Context Window: Set this to at least 32,000 tokens. Coding tasks require significant context to understand multi-file structures.14

Engineering the Bridge: Connecting Cline to n8n via MCP

The core of the “semi-autonomous” functionality lies in the bridge. Without this connection, Cline can only reason about files and run local terminal commands; it cannot leverage the sophisticated automation workflows of n8n. The Model Context Protocol (MCP) enables Cline to discover n8n workflows as if they were built-in tools.7

The Role of the MCP Server in Workflow Execution

There are two primary methods for establishing this bridge, depending on the user’s specific goals. Method A involves using a dedicated bridge package (n8n-mcp) to allow Cline to manage and build n8n workflows.1 Method B utilizes n8n’s built-in “Instance-level MCP” to expose specific workflows as deterministic tools.22

For the purpose of offloading “hard work,” Method B is often superior. It allows the developer to pre-define complex logic in n8n — such as a recursive search across multiple documentation sites — and expose it to Cline as a single, simple tool call.

Interactive Bridge Configuration (stdio Method)

To connect Cline to a local n8n instance, the cline_mcp_settings.json file must be modified. This file is located in the VS Code global storage directory.21 The configuration requires the use of npx to execute the bridge server.1

{
 "mcpServers": {
 "n8n-bridge": {
 "command": "npx",
 "args": ["-y", "n8n-mcp"],
 "env": {
 "MCP_MODE": "stdio",
 "N8N_API_URL": "http://localhost:5678",
 "N8N_API_KEY": "YOUR_N8N_API_KEY",
 "LOG_LEVEL": "error",
 "DISABLE_CONSOLE_OUTPUT": "true"
 }
 }
 }
}

The N8N_API_KEY is generated within the n8n settings dashboard under the “API” tab.

Setting MCP_MODE to stdio is a non-negotiable requirement for Cline to communicate with the bridge via standard input/output streams.1

The Remote Bridge Alternative (SSE Method)

For n8n instances running on remote servers or in the cloud, the “MCP Server Trigger” node is used. This node generates a unique URL that supports Server-Sent Events (SSE). Because Cline expects a local process, a tool like supergateway can be used to bridge the remote SSE endpoint to a local stdio process.

Functional Implementation 1: Internet and Registry Queries

Once the bridge is established, n8n must be configured with workflows that perform the “hard work” of environmental research. The agent’s ability to suggest the correct library depends on real-time data from package registries.

Designing the Language Detection and Routing Logic

Using Docker is required for the “Execute Command” node to have a consistent environment

Bash
docker run -it --rm --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n n8nio/n8n

Access N8N on this port: Open http://localhost:5678 and create your account.
The first node in the n8n workflow after the “Manual Trigger” or “MCP Server Trigger” is typically a Function Node that identifies the programming language and specific ecosystem mentioned in the user’s prompt. This ensures that a request for “a standard HTTP client” routes to the npm registry for Node.js projects or Pub.dev for Flutter projects.

Function Node Example for Detection:

JavaScript

const prompt = $json["prompt"];
let lang = "unknown";
if(prompt.match(/flutter|dart/i)) lang = "flutter";
else if(prompt.match(/node|js|javascript/i)) lang = "node";
else if(prompt.match(/java|maven/i)) lang = "java";
else if(prompt.match(/.net|c#/i)) lang = "dotnet";
return [{json: {language: lang, prompt}}];

Following this detection, a Switch Node routes the flow to the appropriate HTTP Request Node for the respective registry API.

Registry Integration Endpoints

The n8n workflow must utilize the structured APIs provided by package managers. The data returned by these nodes allows the agent to reason about version compatibility and licensing.

By aggregating the results from these endpoints, n8n constructs a response for Cline that includes the top three recommended packages, their current versions, and their installation commands.2 This transforms Cline from a code-generator into an informed consultant.

Functional Implementation : Safe Multi-File Modification

One of the most complex requirements for an autonomous agent is the ability to modify multiple files safely.2 Cline achieves this by maintaining a high-context view of the project, while n8n provides the necessary background checks.

The Reasoning-Execution Cycle

When the agent decides to implement a feature that spans multiple files — such as adding a new API endpoint that requires changes to the controller, the service layer, and the database schema — it follows a specific sequence. First, the agent calls an n8n workflow to “Scrape Documentation” or “Verify Schema”.3 This ensures the agent is working with the most current architectural patterns.

Next, the agent generates the specific code blocks for each file. Cline’s internal logic allows it to “inject” these imports and code changes without rewriting the entire file, which is crucial for preserving existing functionality.2

Safeguarding Multi-File Edits

Safety is maintained through n8n’s ability to act as a pre-validation engine. Before Cline applies the changes to the disk, it can send the proposed diff to an n8n workflow that performs a “Lint Check” or “Syntax Validation” using the Execute Command node.17 If the linting fails, n8n returns the error to Cline, which then adjusts its code generation accordingly. This iterative loop drastically reduces the frequency of broken builds.

Functional Implementation : Multi-Language Test Execution

Validation is the cornerstone of autonomous reliability. The agent must not only write code but also ensure that the code performs as expected across different languages and ecosystems.2

The Execute Command Engine

n8n’s Execute Command node is the primary tool for this validation. When running in Docker, this node can execute shell commands within the n8n container.17 It is important to realize that the default n8n image is based on Alpine Linux and might lack the necessary SDKs for Flutter,.NET, or Java.17

To support multi-language tests, a custom Dockerfile is required to build an augmented n8n image:

Dockerfile

FROM n8nio/n8n:latest
USER root
RUN apk add - no-cache bash curl git openjdk17-jdk python3
# Add Flutter SDK,.NET SDK, etc.
USER node

Once the environment is equipped with the relevant toolchains, n8n can execute tests based on the project type.

Returning Test Results to Cline

The output of these commands (STDOUT and STDERR) is captured by n8n and returned to Cline. The agent interprets these logs; if a test fails, it analyzes the stack trace and attempts a “Self-Correction” cycle.

This autonomous loop

Reasoning -> Editing -> Testing -> Analyzing -> Re-editing
is what distinguishes an agent from a simple chat assistant.

Hands-On Lab: Testing on a Sample Java Repo
Now, test your creation by letting the agent perform a real development task.

Preparation

Create or clone a simple Maven project (e.g., a Spring Boot “Hello World”). Open the project folder in VS Code.

The Autonomous Cycle

Prompt Cline: “I need to implement JSON parsing. Find the latest version of Jackson Databind in the Maven registry, add it to my pom.xml, and then create a new class ‘JsonParser.java’ that converts a sample String to a Map. Finally, run ‘mvn compile’ to ensure it works.”

Dynamic LLM Switching and Cost Management

An enterprise-grade agent must be economically viable. While high-reasoning models like Claude 3.5 Sonnet or GPT-4o are superior for architecture and planning, they are significantly more expensive than local models or lighter cloud models like DeepSeek V3.18

Strategy for Model Orchestration

The system allows for dynamic switching within the Cline settings panel.19 A recommended operational pattern is as follows:

Architectural Design: Use a high-reasoning paid model (e.g., Claude 3.5 Sonnet) to analyze the project structure and plan the multi-file changes.18
Routine Implementation: Once the plan is established, switch to a local model (e.g., Code Llama via Ollama) to generate the repetitive code blocks and unit tests.2
Research Tasks: Offload searches to n8n, which uses free registry APIs and low-cost web search nodes, reducing the token count sent to the primary LLM.2

Performance Optimization and Caching

To further reduce costs and latency, n8n can implement a caching layer for registry and web search results.2 For example, if the agent repeatedly asks for the latest version of axios, n8n can store the result in a local database (like SQLite or Redis) and return the cached version if the last check was within a 24-hour window.2 This not only saves API credits but also makes the agent feel significantly more responsive.

Human-in-the-Loop Logic and Safety Guardrails

Autonomous agents operate with a level of unpredictability that requires deterministic safeguards.11 The system implements Human-in-the-Loop (HITL) logic at critical junctions.

Deterministic Approval in n8n

n8n provides a robust mechanism for HITL. Before an “Execute Command” node runs a potentially destructive shell script or an “HTTP Request” node sends data to a production API, a “Wait for Approval” node can be inserted.38

This workflow pattern typically includes:

1. Request: The agent proposes an action.
2. Notification: n8n sends the details of the action to the developer via Slack, Telegram, or Discord.38
3. Decision: The developer clicks “Approve” or “Reject” in the chat app.
4. Execution: n8n only continues if the approval is received.40

Integrated Safety in Cline

Cline itself offers a layer of HITL by presenting every proposed file change as a diff in VS Code.5 The agent cannot overwrite files without the user specifically allowing the write operation. This dual-layered safety approach — n8n for environment-level actions and Cline for codebase-level actions — ensures that the developer maintains total control over the autonomous process.2

Synthesis of the Agentic Lifecycle

The successful implementation of a semi-autonomous coding agent requires a shift in how developers conceptualize the software development lifecycle. By integrating Cline and n8n via MCP, the workflow becomes a synchronized dance between reasoning and automation. The agent acts as the brain, identifying the “what” and “why” of a task, while n8n acts as the hands and eyes, handling the “how” and the real-world data retrieval.3

The multi-language support is not merely a feature but a byproduct of n8n’s universal connectivity. Whether the project is in Dart, JavaScript, or C#, the agent uses the same bridge to access language-specific tools and registries.2 This modularity allows the system to scale; as new technologies emerge, adding support is as simple as adding a new node to an n8n workflow, without needing to modify the agent’s core reasoning logic.

Conclusion

By isolating Reasoning (Cline/Ollama) from Environmental Interaction (n8n), we have created a modular agent that grows with your needs. While the LLM’s internal data may be outdated, its connection to n8n ensures it always has access to the latest versions in 2026 and beyond.

Why you should take Free Claude Code Skills Assessment

Ved Sharma — Sat, 07 Feb 2026 08:32:18 +0000

You write code every day.
But do you know how well you actually think in code?

The Claude Code Skill Assessment by ThinkHumble is designed to test something interviews often miss
real-world reasoning, not just syntax.

What this assessment really measures

✔ Your ability to understand large codebases
✔ How you break down and solve problems
✔ Your skill in refactoring, debugging, and explaining code
✔ How effectively you use AI-assisted reasoning (yes, the future skill)

This isn’t about speed.
It’s about thinking like an engineer.

Why it matters

Developers who complete this assessment:
• Demonstrate real-world coding judgment
• Showcase AI-augmented development skills
• Stand out beyond resumes and interviews

Bonus

✅ Get a FREE certificate
✅ Add credibility to your profile
✅ Prove how well you reason with code — not just write it

Take the Free Claude Code Skill Assessment now https://forms.gle/oAzmsHDGz9pjM2MG7

𝐓𝐡𝐢𝐧𝐤 𝐲𝐨𝐮 𝐫𝐞𝐚𝐥𝐥𝐲 𝐤𝐧𝐨𝐰 𝐲𝐨𝐮𝐫 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐒𝐤𝐢𝐥𝐥𝐬? ☁️ 𝐎𝐫 𝐚𝐫𝐞 𝐲𝐨𝐮 𝐣𝐮𝐬𝐭 𝐠𝐮𝐞𝐬𝐬𝐢𝐧𝐠?

Ved Sharma — Tue, 03 Feb 2026 11:41:04 +0000

Built for 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐞𝐧𝐭𝐡𝐮𝐬𝐢𝐚𝐬𝐭𝐬, 𝐁𝐞𝐠𝐢𝐧𝐧𝐞𝐫𝐬, 𝐢𝐧𝐭𝐞𝐫𝐦𝐞𝐝𝐢𝐚𝐭𝐞𝐬, 𝐚𝐧𝐝 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐞𝐱𝐩𝐞𝐫𝐭𝐬 alike, a way to test your skills, benchmark yourself, and get actionable insights instantly.

𝐑𝐞𝐠𝐢𝐬𝐭𝐞𝐫 𝐇𝐞𝐫𝐞: https://forms.gle/PqCgPgMdhHTneHSq9

Careers in Cybersecurity: Building a Secure Digital Future

Ved Sharma — Tue, 03 Feb 2026 07:43:13 +0000

Why Cybersecurity Has Become One of the World’s Most In-Demand Career Paths

As digital transformation accelerates across industries worldwide, cybersecurity has emerged as one of the most critical and future-ready career paths. Organizations across finance, healthcare, education, manufacturing, and technology rely heavily on digital infrastructure, cloud platforms, and data-driven systems. This global dependence on technology has created a strong demand for professionals who can identify risks, respond to cyber threats, and ensure digital trust.

To gain deeper insight into how cybersecurity careers are evolving globally, watch this in-depth discussion:
👉 Watch the full video: https://youtu.be/Fj4cDMv5qsU

Cybersecurity is considered a future-proof career because security challenges evolve alongside technology. While tools and platforms continue to change, the need to protect systems, data, and users remains constant. As cyberattacks grow more sophisticated and frequent, organizations are shifting their focus from credentials alone to validated, role-ready cybersecurity skills that reflect real-world capability.

Key Career Roles in Cybersecurity

Cybersecurity offers diverse global career opportunities, including:

Security Analyst — Monitors systems, investigates threats, and analyzes vulnerabilities
SOC Analyst — Responds to incidents in real time within security operations environments
Penetration Tester (Ethical Hacker) — Simulates attacks to uncover security weaknesses
Cloud Security Specialist — Secures cloud-based and hybrid infrastructures
Governance, Risk, and Compliance (GRC) Professional — Ensures alignment with global security standards and regulations
Each role requires a blend of technical knowledge, analytical thinking, and situational awareness.

Skills That Matter in Today’s Market

Modern cybersecurity careers emphasize practical skills over theoretical knowledge. Employers worldwide value professionals who can:

● Solve security problems using real-world scenarios
● Apply role-specific security expertise
● Respond effectively to cyber incidents
● Understand attacker behavior and threat models
● Communicate risks clearly to technical and business teams

This shift has increased the importance of GenAI-powered skill evaluation, adaptive assessments, and behavioral simulations. Platforms like ThinkHumble enable scalable, SME-free, role-based cybersecurity assessments that help organizations evaluate real readiness and gain actionable talent insights.

Career Growth in the Age of GenAI

Cybersecurity offers strong long-term career progression, from entry-level roles to advanced positions such as Security Architect, Consultant, or Chief Information Security Officer (CISO). GenAI enhances this journey by enabling predictive insights and realistic skill evaluation while keeping human judgment at the center.

In a globally connected digital economy, cybersecurity careers provide stability, growth, and meaningful impact by protecting systems, data, and trust.

Lets decipher versioning hell

Ved Sharma — Sat, 17 Jan 2026 06:12:02 +0000

Often heard of seen by all of new version of IPhone is getting released or new version of Windows is getting released. What does that mean ? and Why you care about a version ?

Lets discuss the nuance of versioning software or hardware in detail and Semantic versioning specifically. Take a example some company ABC is trying to create a Ticket booking platform and it started to support searching a flight and booking in version 1.0.0, but now there is an issue in the booking system it is booking 2 tickets instead of one.

So this is a bug and should be fixed. So ABC is going to release a new version of software say 1.0.1.

Now an obvious question why not 2.0.0 that is much easier to understand and follow correct ?

That is where semantic versioning comes into play whenever software of hardware is patched essentially fixed for certain bugs it will increment last digit of semantic version string in this case it is 1.0.0 to 1.0.1.

Now lets understand another scenario, same company ABC wants to add an option of seat selection to its interface and release a new feature on its website now it will name this version as 1.1.0.

Curios why it is not named as 2.0.0 ?
Answer to above question is since this is an incremental change and it will not break the experience of the user that is backward compatible with older feature thus it is kept as 1.1.0. For example if someone don’t want to do seat selection still want to book is still guaranteed.

Now one last scenario, imagine same ABC company want to start train booking and release a new version of application and name it 2.0.0.

This time you wonder why this has moved to 2.0.0 ?

Answer is this change is a bigger change a new stream of work or new user experience has been enabled thus application is version to 2.0.0. Here newer changes may not be compatible with the older one say a new feature working on this version may not work for those seamlessly if added to the older version until an effort is made to back port it on older version. For example ABC may put a restriction of booking Airline ticket with seat selection as mandatory which was not there earlier.

Semantic string syntax is MAJOR_VERSION.MINOR_VERSION.PATCH_VERSION.

So next time you upgrade your phone software just observe the string coming on your screen.

🌐 Explore more at www.thinkhumble.in

LLM Parameter fine tuning with Spring AI

Ved Sharma — Wed, 07 Jan 2026 12:30:01 +0000

Ever wondered what it takes to be more creative while generating a story with LLM versus doing a technical task, answer lies in the parameters of LLM you play around, if you know what to pick and choose for a given activity results will be significantly different.

This tutorial explains how to “tune” the behavior of your Large Language Models (LLMs) using Spring AI.

It is important to clarify a technical distinction: while “finetuning” often refers to retraining a model on new data, most developers use the term to describe Inference Parameter Tuning — adjusting the “knobs” that control how a model generates text in real-time. Spring AI makes this easy through the ChatOptions interface.

1. Understanding the “Knobs”

Before diving into code, let’s understand the primary parameters you can control.

- Temperature: Controls randomness. A value of 0 makes the model deterministic (it will always pick the most likely word). A value of 1.0+ makes it highly creative and unpredictable.
- Top-P (Nucleus Sampling): The model considers only the tokens whose cumulative probability reaches the value P (e.g., 0.9). It’s more dynamic than Top-K.
- Top-K: The model only considers the top $K$ most likely next words. This “cuts the tail” of low-probability words.
- Frequency Penalty: Discourages the model from repeating the same words or phrases.
- Presence Penalty: Encourages the model to talk about new topics.

2. Spring AI Implementation

In Spring AI, you can set these parameters globally in your application.properties or per-request using ChatOptions.

Per-Request Configuration (Recommended)

This approach allows you to use different settings for different parts of your app (e.g., a “Creative Story” endpoint vs. a “Data Extraction” endpoint).

@RestController
public class ChatController {
private final ChatClient chatClient;
public ChatController(ChatClient.Builder builder) {
this.chatClient = builder.build();
}
@GetMapping("/creative-chat")
public String creativeChat(@RequestParam String message) {
return chatClient.prompt()
.user(message)
.options(OpenAiChatOptions.builder()
.withTemperature(0.9f) // High creativity
.withTopP(0.9f) // Diverse vocabulary
.withMaxTokens(500) // Length limit
.build())
.call()
.content();
}
@GetMapping("/precise-chat")
public String preciseChat(@RequestParam String message) {
return chatClient.prompt()
.user(message)
.options(OpenAiChatOptions.builder()
.withTemperature(0.1f) // Low randomness
.withFrequencyPenalty(0.5f) // Prevent repetition
.build())
.call()
.content();
}
}

Global Configuration

If you want a consistent “vibe” across your entire application, use application.properties:
Properties

spring.ai.openai.chat.options.temperature=0.7
spring.ai.openai.chat.options.model=gpt-4o
spring.ai.openai.chat.options.top-p=1.0

3. Parameter Recommendations by Use Case

Choosing the right values depends entirely on your goal. Here is a guide for common scenarios:

4. Pro-Tips for Tuning

Don’t tweak both Temp and Top P: Most AI labs (like OpenAI) recommend adjusting either Temperature or Top-P, but not both at once, as they can conflict or produce erratic results.
Use 0 for JSON: If you are using Spring AI’s BeanOutputConverter to get structured data, set Temperature to 0. Hallucinations in JSON keys will break your code.

Frequency vs. Presence: Use Frequency Penalty if the model gets stuck repeating a specific word. Use Presence Penalty if the model keeps circling back to the same concept.

Connect with me at below email if you need a curated learning path for yourself in AI/Gen AI. It does not matter which stream or role you come from. There is a learning path for everyone.

connect@thinkhumble.in

Why Log levels matter?

Ved Sharma — Tue, 30 Dec 2025 09:42:29 +0000

The Definitive Guide to Log Levels and Centralized Logging

Ever wondered why people dont use system.out to print/log ? Or why at one place someone use log.debug and other places log.info. Why your review comments always ask for more logging statements. Why it matters to choose right logging level. How to effectively use it ?

Effective logging is the backbone of application health monitoring and debugging. By consistently and correctly using log levels, developers can maintain a crucial b*alance between visibility and noise* across all environments.

Understanding Log Levels and Their Usage

Log levels are a hierarchical system used to categorize the severity or importance of a log message. The common hierarchy, from least to most severe, is generally:

TRACE: Very granular information, typically used for detailed tracing of a request or process flow. You’d enable this only for deep, short-term debugging.

1. DEBUG: Fine-grained informational events that are most useful to debug an application. This includes variable values, entry/exit points of methods, and steps taken within a process.

2. INFO: Confirmation that things are working as expected. This level provides general application health and progress messages, such as service startup/shutdown, major state changes, or successful key operations. This is often the default level for production environments.

3. WARN: Potentially harmful situations or unexpected events that might indicate a problem but do not necessarily prevent the application from continuing. Examples include use of deprecated APIs, hitting a soft limit, or a recoverable failure.

4. ERROR: Serious errors that prevent certain parts of the application from functioning, but the application as a whole might still be running. Examples are exceptions that cause a feature to fail.

5. FATAL: Very severe error events that will likely cause the application to abort. This is usually reserved for catastrophic failures that bring down the entire system or a critical component.

WARN vs. INFO: Distinguishing the Difference

Java Logging Anti-Patterns

Why Avoid e.printStackTrace()
Calling e.printStackTrace() directly within application code is highly discouraged:

1. Uncontrolled Output Stream: It writes directly to the** Standard Error Stream (System.err)**, bypassing the configured logging framework (e.g., Log4j, SLF4J).

2. No Filtering or Formatting: The output cannot be formatted (no timestamp, log level) and cannot be filtered.

3. Bypasses Log Destination: It ignores your configuration for centralized systems like Splunk.

The recommended practice is to log the exception using the framework at the ERROR level, ensuring the full stack trace is captured:

// Preferred approach:
try {
// … code that might throw an exception
} catch (Exception e) {
logger.error(“Error processing request X”, e); // The ‘e’ parameter logs the full stack trace
}

The Problem with System.out.println()

Using System.out.println() for application logging is problematic because it

1. Writes to Standard Output Stream (System.out): This bypasses the logging framework entirely, leading to unstructured and untagged output.

2. No Context: The message lacks crucial metadata like the log level, timestamp, or thread name.

3. Inflexible Configuration: You cannot easily control or filter the output without code redeployment.

Sending Logs to Centralized Systems (Splunk, LogicMonitor, etc.)

To leverage the power of Centralized Logging Systems (Splunk, LogicMonitor, ELK Stack), you must configure your logging framework (Log4j, Logback) to direct output to them. This is done via Appenders (or Handlers) in your external configuration file.

1. The Robust Approach: File-Based Logging with an Agent (Recommended)

This is the most common and reliable method, favored by large-scale deployments:

● Application Action: The application uses a standard RollingFileAppender to write highly structured logs (preferably JSON) to a local file.

● Agent Action: A dedicated, lightweight log forwarding agent (e.g., Splunk Universal Forwarder, LogicMonitor Collector, Fluentd) runs on the same server.

● Shipping: The agent is configured to “tail” (monitor) the application’s log file, read new entries in real-time, and forward them over the network to the central log aggregator.

Benefit for Centralized Logging

Reliability Logs are safely stored locally if the network or collector is down, ensuring no data loss.

Performance Writing to a local file is much faster than synchronous network calls.

Parsing The agent can standardize the data into JSON or key-value pairs before ingestion.

2. Direct Network Appenders

For specialized needs, you can configure the logging library to send logs directly over the network:

• Network Protocol Appender: Configure an appender to send logs via a protocol like Syslog (TCP/UDP).

• HTTP/API Appender: Use a specialized appender (like SplunkHttpEventCollectorAppender) to send structured JSON data directly to the vendor’s API endpoint.

Crucially, no modification to the application’s core logging calls is needed. You continue to use standard calls (e.g., logger.info(…)). The logging framework handles the delivery mechanism based on the external configuration file.

Summary and Best Practices

Choosing the right log level is a fundamental step in building maintainable software.

Log Level Usage Guidelines

Potential Pitfalls of Using Wrong Log Levels

Multi step RAG with Spring AI

Ved Sharma — Wed, 24 Dec 2025 13:52:32 +0000

Standard Retrieval-Augmented Generation (RAG) follows a simple, linear path: take a user query, find similar documents, and send them to the LLM. While effective for basic FAQs, this “one-shot” approach fails when faced with complex, real-world problems.

This guide explores Multistep RAG, a sophisticated pattern where the AI system functions as an agent — reasoning, searching, and refining its answers through multiple iterations.

1. When is Multistep RAG Required?

In a production environment, you should transition from simple RAG to a multistep architecture when your system encounters:

- Multi-Hop Reasoning: When an answer requires connecting two unrelated facts (e.g., “How does the CEO’s bonus in our 2023 report compare to the market average for tech firms in 2024?”). One search won’t find both pieces of data.
- Missing Context (The “Web Bridge”): When internal documents are outdated or incomplete. The system must recognize it lacks info and “step out” to a web search tool.
- Query Ambiguity: When the user’s initial question is too broad. The system needs a “Query Transformation” step to break one question into three specific sub-queries for the vector database.

Spring AI vs. LangChain: The Orchestration Battle

2. Project Configuration (pom.xml)

As of late 2025, Spring AI 1.1.x and 2.0.x provide the most robust support for these patterns. Ensure you have the following dependencies:

XML

<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-openai-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-tavily-ai-spring-boot-starter</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bom</artifactId>
<version>1.1.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

3. Implementation: Multistep RAG with Web Search

In this architecture, the ChatClient uses a RetrievalAugmentationAdvisor to fetch internal data and a ToolCallAdvisor to perform external web searches if the model determines it is necessary.

Step 1: Define the Web Search Tool

First, we expose a web search function as a Spring Bean. The LLM will “see” this tool and its description.

@Configuration
public class AiToolsConfig {
@Bean
@Description("Search the internet for real-time news, current events, or missing technical data.")
public Function<SearchRequest, String> webSearch(TavilyAiApi tavilyApi) {
return request -> {
var response = tavilyApi.search(new TavilyAiApi.SearchRequest(request.query()));
return response.results().toString();
};
}
public record SearchRequest(String query) {}
}

Step 2: The Service with Re-ranking logic

To ensure the model isn’t overwhelmed by “noise” from the web or internal docs, we implement a DocumentPostProcessor for re-ranking.

@Service
public class AdvancedRagService {
private final ChatClient chatClient;
public AdvancedRagService(ChatClient.Builder builder, VectorStore vectorStore) {
// 1. Setup the Multi-step Retriever with a Re-ranker
var retrievalAdvisor = RetrievalAugmentationAdvisor.builder()
.documentRetriever(VectorStoreDocumentRetriever.builder()
.vectorStore(vectorStore)
.topK(15) // Get a wide pool first
.build())
.documentPostProcessors(List.of((query, docs) -> {
// Here you would integrate a model like Cohere Rerank
// For now, we simulate a 'Two-Stage' filter
return docs.stream().limit(5).toList();
}))
.build();
// 2. Build the Agentic ChatClient
this.chatClient = builder
.defaultAdvisors(
retrievalAdvisor, // Internal RAG
new ToolCallAdvisor(List.of("webSearch")) // Web Tool
)
.build();
}
public String execute(String userPrompt) {
return this.chatClient.prompt().user(userPrompt).call().content();
}
}

4. The Re-ranking Step (Two-Stage Retrieval)

The most common reason for RAG failure is that the “top 3” documents found by vector math aren’t actually the best ones. Re-ranking solves this by taking a larger set (e.g., top 20) and running a more expensive “relevance score” on them.

When implementing a custom re-ranker, you effectively compute a score $S = f(Query, Document)$ for every retrieved chunk, ensuring that the documents with the highest semantic signal are placed at the beginning of the prompt.

5. Potential Pitfalls to Avoid

Creating a multistep system introduces “Agentic” risks that standard RAG does not face:

- The Infinite Search Loop: If the LLM is unsatisfied with search results, it may call the web search tool repeatedly.
- Solution: Always set maxToolCalls in your ChatOptions to cap the number of iterations.
- Context Drift: In a 3-step search, the prompt grows significantly as each step adds more text. This can cause the model to lose the original user intent.
- Solution: Use a CompressionQueryTransformer to summarize previous search results before the final generation.
- Latency vs. Accuracy: Every “hop” adds 1–3 seconds of delay.
- Solution: Only trigger the web tool if the internal vector search similarity score is below a certain threshold (e.g., < 0.7).
- Hallucination in the “Reasoning” Step: The model might invent a “fact” during Step 1 that it then uses to search the web in Step 2.
- Solution: Use an Evaluator Advisor to check if the tool output contradicts the initial retrieved internal context.

Lets start with Spring AI

Ved Sharma — Tue, 23 Dec 2025 06:23:09 +0000

Spring AI : Your First Step into Generative AI with Java

Often Java based enterprise systems find it difficult to work with Python libs and related tool chains. Introducing Spring AI, an open-source framework designed to simplify the development of applications that incorporate Artificial Intelligence capabilities, specifically Large Language Models (LLMs), using the familiar patterns of the Spring ecosystem.

If you are a Java developer looking to integrate powerful features like ChatGPT or Google Gemini into your enterprise applications without wrestling with provider-specific SDKs, Spring AI is the perfect tool.

What is Spring AI?

At its core, Spring AI acts as a common abstraction layer for AI models.

Think of it like Spring Data JPA for databases: just as Spring Data abstracts away SQL and database specifics, Spring AI abstracts away the differences between various AI providers (OpenAI, Google, Azure, Anthropic, etc.).

This approach offers two huge benefits:

1. Portability: You can switch between different AI models and providers with minimal code changes, allowing you to choose the most cost-effective or highest-performing model for your use case.
2. Familiarity: It uses standard Spring concepts like dependency injection, auto-configuration, and fluent APIs (like WebClient or JdbcClient), making the learning curve shallow for millions of existing Spring developers.

Why Use Spring AI Over LangChain?

While LangChain is a powerful, provider-agnostic framework that popularized the “chaining” of LLM calls, it is primarily built for the Python ecosystem. Spring AI, on the other hand, is built from the ground up to be idiomatic Java and integrate seamlessly into Spring Boot applications.

Here is why a Java enterprise developer should strongly consider using Spring AI:

The “Idiomatic Java” Advantage

For a Java team, choosing Spring AI means:

- No Polyglot Complexity: You avoid introducing Python dependencies, virtual environments, and inter-process communication headaches into your production Java environment.
- Performance: Spring AI runs natively within the Java Virtual Machine (JVM), leveraging its excellent garbage collection and performance optimizations.
- Tooling: You benefit from static type checking, robust debugging, and the full ecosystem of Java testing frameworks (JUnit, Mockito).
In short, if your application is written in Java and uses Spring Boot, Spring AI is the natural, lowest-friction choice for integrating generative AI.

Key Concepts in Spring AI

To build a basic AI application, you need to understand three core components:

Building a Simple Chat Service

Let’s create a minimal Spring Boot application that uses the ChatClient to generate responses based on a user’s message. For this example, we will use the OpenAI model.

1. Project Setup (Maven)

Add the following to your pom.xml file:

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-openai-spring-boot-starter</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bom</artifactId>
<version>1.0.0</version> <type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

2. Configuration (application.properties)

You need to provide your AI provider’s API key. Place this in your src/main/resources/application.properties file.

Properties

Replace with your actual OpenAI API Key

spring.ai.openai.api-key=<YOUR_OPENAI_API_KEY>

3. The Controller (AiController.java)

This class defines a REST endpoint that accepts a message and uses the injected ChatClient to get a response.

Java
package com.example.aidemo;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class AiController {
private final ChatClient chatClient;
/**
* Spring Boot automatically configures and injects the ChatClient based
* on the dependency and properties.
*/
public AiController(ChatClient.Builder chatClientBuilder) {
// Build the ChatClient instance using the injected builder
this.chatClient = chatClientBuilder.build();
}
@GetMapping("/generate")
public String generate(@RequestParam(value = "message", defaultValue = "Tell me a short, friendly joke.") String message) {
// Use the fluent API to define the prompt and call the model
return chatClient.prompt()
.user(message) // Set the user's input message
.call() // Execute the call to the AI model
.content(); // Extract the plain text content from the response
}
}

4. Run and Test

Run your Spring Boot application.
Test the endpoint: http://localhost:8080/generate?message=Explain%20Spring%20AI%20in%20one%20sentence

Connect with me if you need advice on clearing your next tech interview at top tier companies by commenting on this post or email at connect@thinkhumble.in

RAG with Spring AI

Ved Sharma — Fri, 19 Dec 2025 12:46:54 +0000

Build a Context-Aware Application

RAG is in place now from at 2–3 years, still there is not much clarity on this aspect in Java ecosystem, though efforts have been made via LangChain4J but it is not that clear like mature frameworks like as spring.

Retrieval-Augmented Generation (RAG) is a pattern that enhances Large Language Models (LLMs) by providing them with external, up-to-date, or proprietary data, which reduces hallucinations and grounds the response in facts. Spring AI provides an idiomatic and seamless way to implement RAG within the Spring Boot ecosystem.

Introduction: Spring AI vs. LangChain

Spring AI is a framework that aims to apply Spring ecosystem design principles — such as portability (across models and vector stores) and modular design — to the AI domain. It is a natural choice for Java/Spring Boot developers as it fully embraces Spring conventions like Dependency Injection, auto-configuration, and POJOs (Plain Old Java Objects).

Spring AI can be a strong alternative to LangChain (and its Java port, LangChain4j) for RAG, especially within an enterprise setting, because:

- Seamless Spring Boot Integration: It uses Spring Boot starters, making setup incredibly fast. You get an automatically configured ChatClient and VectorStore by simply adding dependencies and properties.
- Idiomatic Java: The APIs feel like other Spring APIs (like WebClient or JdbcTemplate), leveraging familiar patterns for Java developers.
- Enterprise-Grade Features: It is backed by the Spring ecosystem, inheriting robust features like observability, security, and consistent configuration.
- Focus on Abstraction: It provides high-level abstractions like the Advisor API for RAG, which encapsulates the entire retrieval and prompt augmentation logic, often requiring less boilerplate than manually stitching together a chain.

Prerequisites

To follow this tutorial, you will need:

Java 21 or later.
Maven or Gradle.
An API Key for an LLM provider (e.g., OpenAI, Google Gemini, etc.). We will use OpenAI for this example.
The latest Spring AI Bill of Materials (BOM). We will assume the latest stable version of Spring AI is used.

Step 1: Project Setup (Using Maven)

Create a new Spring Boot project (e.g., using start.spring.io) and add the following dependencies. We will use the OpenAI model and the PostgreSQL/PGVector vector store for a robust, production-ready setup.

In your POM.xml add

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-bom</artifactId>
            <version>1.0.0</version> <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-pdf-document-reader</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>
    </dependencies>

Step 2: Configuration

Configure the LLM API key and the PostgreSQL vector store in your application.properties (or application.yml).

Note: For the PGVector store, you’ll need a running PostgreSQL database with the pgvector extension enabled. Using Docker Compose is recommended for local development.

Properties
# LLM Configuration (OpenAI Example)
spring.ai.openai.api-key=${OPENAI_API_KEY}
spring.ai.openai.chat.model=gpt-4o-mini
spring.ai.openai.embedding.model=text-embedding-3-small

# PostgreSQL/PGVector Configuration
spring.datasource.url=jdbc:postgresql://localhost:5432/ragdb
spring.datasource.username=user
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update

# Spring AI Vector Store Schema Initialization
# This creates the necessary table for the vector store
spring.ai.vectorstore.pgvector.initialize-schema=true

Step 3: Document Ingestion Service (ETL)

The first part of RAG is the Extract, Transform, Load (ETL) pipeline. We read a document, split it into smaller chunks (documents), generate embeddings for the chunks, and store them in the VectorStore.

Create a service named IngestionService.java:

package com.example.ragtutorial;

import org.springframework.ai.document.Document;
import org.springframework.ai.reader.TextReader;
import org.springframework.ai.transformer.splitter.TokenTextSplitter;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Service;

import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Service
public class IngestionService implements CommandLineRunner {

    private static final Logger log = LoggerFactory.getLogger(IngestionService.class);
    private final VectorStore vectorStore;

    // Use a text file for simplicity. Place it in src/main/resources/data/
    @Value("classpath:/data/spring-ai-info.txt")
    private Resource dataResource;

    public IngestionService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    @Override
    public void run(String... args) {
        log.info("Starting RAG document ingestion...");

        // 1. Extract: Read the document content
        TextReader textReader = new TextReader(dataResource);
        List<Document> rawDocuments = textReader.get();

        // 2. Transform: Split the large document into smaller, manageable chunks
        // TokenTextSplitter ensures chunks fit within the LLM's context window
        TokenTextSplitter textSplitter = new TokenTextSplitter();
        List<Document> splitDocuments = textSplitter.apply(rawDocuments);

        // 3. Load: Store the documents (which creates and stores embeddings)
        vectorStore.accept(splitDocuments);

        log.info("Document ingestion complete. {} chunks loaded into VectorStore.", splitDocuments.size());
    }
}

Example content for src/main/resources/data/spring-ai-info.txt:

Spring AI is an application framework for AI engineering. Its goal is to apply Spring ecosystem design principles to the AI domain. It connects enterprise data and APIs with AI Models. It offers a portable API across different AI providers like OpenAI, Gemini, and Ollama. For RAG, it supports vector stores such as PGVector, Chroma, and Redis. The ChatClient API is used for communication, and the Advisor API simplifies patterns like RAG.

Step 4: Implement the RAG Controller

The RAG logic is greatly simplified by Spring AI’s Advisor API, specifically QuestionAnswerAdvisor. This advisor automatically performs the retrieval and prompt augmentation before calling the LLM.

Create a REST controller named RagController.java

package com.example.ragtutorial;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.ai.chat.client.advisor.QuestionAnswerAdvisor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RagController {

    private final ChatClient chatClient;

    public RagController(ChatClient.Builder chatClientBuilder, VectorStore vectorStore) {
        // Configure the ChatClient with the QuestionAnswerAdvisor
        // The QuestionAnswerAdvisor handles:
        // 1. Retrieving relevant documents from the VectorStore based on the user query.
        // 2. Augmenting the user's prompt with the retrieved documents as context.
        this.chatClient = chatClientBuilder
            // This is the core of RAG implementation in Spring AI
            .defaultAdvisors(QuestionAnswerAdvisor.builder(vectorStore).build())
            .build();
    }

    @GetMapping("/rag/query")
    public String ragQuery(@RequestParam(defaultValue = "What is Spring AI and what are its features?") String query) {

        // The advisor runs before this call, injecting the retrieved context into the prompt
        return this.chatClient.prompt()
            .user(query)
            .call()
            .content();
    }
}

Step 5: Run and Test the Application

1. Ensure PostgreSQL is running with pgvector enabled (e.g., via Docker).
2. Run the Spring Boot application. The IngestionService will execute upon startup, loading your document into the vector store.
3. Test the RAG endpoint using a browser or a tool like cURL:
Query based on the context:

curl 'http://localhost:8080/rag/query?query=What is the primary goal of Spring AI?'

# Expected Output (grounded in your document): The primary goal of Spring AI is to apply Spring ecosystem design principles to the AI domain and to connect enterprise data and APIs with AI Models.

Conclusion and Shortcomings of RAG

RAG with Spring AI is a powerful and convenient pattern. However, the RAG approach itself, regardless of the framework, has inherent shortcomings:

1. The “Garbage In, Garbage Out” Problem: The quality of the final answer is directly dependent on the quality of the retrieved documents. If the source documents are poorly structured, incomplete, or the chunking is sub-optimal, the LLM will still provide a poor or hallucinated answer.

Fix: Requires a robust ETL pipeline for document cleaning and structured chunking.

1. Need for Fine-Tuning Retrieval: Simple vector similarity search is not always enough.
2. Advanced scenarios require:

Re-ranking: Using a separate model to re-score the top-K retrieved documents for better relevance.
Query Transformation: Using the LLM to rewrite the user’s question into multiple, more specific queries to boost recall (MultiQueryExpander in Spring AI).
Hybrid Search: Combining vector search with traditional keyword search (lexical search) to cover more bases.

1. Context Window Management: The retrieved documents must fit within the LLM’s context window. If too many relevant chunks are found, they must be truncated or summarized, which can lead to incomplete answers.

Integration Complexity (Spring AI Specific): While simple RAG is easy, more complex agentic workflows or highly customized multi-step reasoning often require more explicit configuration than the high-level Advisor abstraction, potentially leading to more code than in a framework designed primarily for chaining (like LangChain4j).

What’s there in a Jar?

Ved Sharma — Thu, 18 Dec 2025 11:33:29 +0000

Many a times when we bundle an application in form of Jar, we need to checkout what is there in it. This is especially true when something goes wrong or application fails to startup in production or controlled environments where you don’t have access to UI tools. That is when this Jar utility come handy.

We will discuss how to use this utility to view, extract, re-bundle and update the existing resources added to the application.

Lets say your build system is creating a jar name connector-utility.jar and you want to list down all the content of this jar bundle, all you have to do is
You will see something like this

jar -tvf connector-utility.jar 0 Thu Jun 30 16:15:04 IST 2022 META-INF/ 476 Thu Jun 30 16:15:04 IST 2022 META-INF/MANIFEST.MF 0 Fri Feb 01 00:00:00 IST 1980 org/ 0 Fri Feb 01 00:00:00 IST 1980 org/springframework/ 0 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/ 0 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/ 5871 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/ClassPathIndexFile.class 6806 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/ExecutableArchiveLauncher.class 3966 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/JarLauncher.class 1483 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/LaunchedURLClassLoader$DefinePackageCallType.class 1535 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/LaunchedURLClassLoader$UseFastConnectionExceptionsEnumeration.class 11154 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/LaunchedURLClassLoader.class 5932 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/Launcher.class 1536 Fri Feb 01 00:00:00 IST 1980 org/springframework/boot/loader/MainMethodRunner.class

Now lets say you want to replace one the files from the above listing with new file, it can be any file including properties file/Meta-Inf file. All you have to do is run this command. You can pass multiple files as well in one go to update as well.

jar -uvf connector-utility.jar ./org/springframework/boot/loader/MainMethodRunner.class

Lets say you want to extract entire jar and see the content for debugging/replacement purpose. You can use this command.

java -xvf connector-utility.jar

Lets say you updated or remove all the stuff that is needed and bundle it again, you can use below command. This will allow jar utility to go out directory in current path and bundle all the files under it with name connector-utility.jar.

jar -cvf connector-utility.jar -C out/ .

AI Didn’t Replace Developers. It Exposed the Gap Between Knowing and Doing.

Ved Sharma — Wed, 17 Dec 2025 08:01:26 +0000

AI didn’t take your job.

It just asked a question most developers were never prepared to answer:

“Can you actually do this… or have you just seen it before?”

That’s the uncomfortable truth many of us are facing in 2025.

The Day AI Stopped Being a Tool

At first, AI felt like magic.

Autocomplete.
Refactors in seconds.
Boilerplate gone.
Productivity went up overnight.

Then something strange happened.

Two developers started using the same AI tools.
One flew ahead.
The other got stuck, constantly rewriting prompts, fixing broken logic, unsure why things weren’t working.

Same AI.
Very different outcomes.

That’s when it became clear:

AI doesn’t replace developers.
It amplifies whatever skill foundation you already have.

Knowing ≠ Doing (And AI Made That Obvious)

For years, the industry rewarded familiarity.

“I’ve worked with React.”

“I know microservices.”

“I’ve used Kubernetes.”

But AI doesn’t care about exposure.
It cares about understanding.

If you don’t grasp:

why a solution works

what tradeoffs exist

where edge cases hide

how systems fail in production

AI won’t save you.

It will happily generate code and quietly expose that you don’t know how to evaluate it.

The Skill Gap Nobody Talks About

This isn’t about juniors vs seniors.

Some of the most affected developers are experienced ones.

Why?

Because years in a job can mask skill decay.
You get comfortable.
You reuse patterns.
You stop questioning fundamentals.

Then AI arrives and suddenly:

juniors with strong fundamentals move faster

generalists outperform specialists stuck in old stacks

people who think clearly outperform people who memorized a lot

The gap wasn’t created by AI.
It was always there.

AI just turned on the lights.

The Real Divide: Builders vs Describers

AI exposed a sharp divide:

Describers-

Know the right terminology

Can explain concepts verbally

Depend heavily on prompts

Struggle to debug AI-generated output

Builders-

Understand cause and effect

Break problems into constraints

Spot flaws in AI output instantly

Use AI as leverage, not a crutch

AI doesn’t make builders obsolete.

It makes them dangerously efficient.

Why Interviews Feel Broken Now

Traditional hiring struggles in an AI world.

Because:

resumes list tools, not thinking

interviews test recall, not judgment

years of experience don’t equal skill depth

AI forced an uncomfortable realization:

If skills can’t be measured clearly,
they can’t be trusted by employers or by developers themselves.

The Most Important Shift Developers Must Make

The future isn’t about learning more tools.

It’s about knowing exactly where you stand.

Not emotionally.
Not based on confidence.
Not based on job title.

But in terms of:

problem-solving depth

real-world decision making

adaptability across unknown scenarios

ability to reason when documentation doesn’t help

Some teams are already experimenting with structured skill clarity approaches (platforms like ThinkHumble focus on this idea), but the bigger shift is personal: developers taking ownership of understanding their real capabilities.

A Quiet Truth Most People Avoid

AI didn’t lower the bar.

It removed the excuses.

You can no longer hide behind:

busy work

long hours

familiarity with frameworks

impressive resumes

Only one thing matters now:

Can you think, adapt, and execute when the problem isn’t obvious?

That’s not something AI replaces.

That’s something AI reveals.

The safest place in an AI-driven industry isn’t “experienced.”

It’s clear.

Clear about what you know.
Clear about what you don’t.
Clear about how you grow.

Because in the end:

AI doesn’t decide your future.
Your skill clarity does.

If this made you question where you actually stand as a developer,
I’ve been using structured skill gap analysis tool to get an objective view of strengths and blind spots beyond resumes and interviews.

Have questions? Shoot.
Happy to share what I know and learn along the way.