Introduction

My past encounters with LLMs were far from impressive. So, what made me decide to give them another chance?

• I saw a GitHub repository showing a full OAuth2 Provider built using Claude. One commit per prompt. I didn't follow all commits, but it was nice to see that this was possible.
• Clojure-MCP ; I didn't knew at that time precisely how that could be a game changer, but it is.
• Heard good things about Claude for programming and I saw a few web app made from just a few directives.

The Setup

Setting things up was not straightforward. But once done I must admit I was really impressed.

I feel AI Agent are now like Versioning System (git) and Build Systems (make). These are tools worthy of learning. But from my experience they only provide value if you have a full setup:

• Agent: The AI needs to work on its own, handling several connected tasks without asking for your input every time.
• Clojure-MCP; it makes these tools way better, even if you code in another language.
• RAG; the system must support file/buffer context to add in order to be able to follow your project best practices.

See my previous article to see all details of my current setup.

Productivity Gain

(--) Hard/Advanced Programming

First, let's make it clear. For real, production-ready, quality development or complex tasks with advanced requirements these tools are a NET NEGATIVE.

If the task at hand is not small in scope, with a clear specification the system will act as a confidently wrong junior developer. In the end, most your time will be lost.

Worse than that, discovering the problems generated by the tools will not be a trivial task, and in the end result in a lot more time loss than if you would simply not have used any AI Agent.

So be conscious about the difficulty of the task at hand.

(+) Boilerplate

For writing boilerplate code following your project's best practices I would say my experience was positive. Some subtle errors could appear, and this was not great. Still, it is faster to use the AI for the boilerplate than typing it yourself most of the time.

(++) Small disposable scripts that don't need to be reliable

If you need to write a script that don't need to be highly reliable. In that case, I can say my experience was a BIG NET POSITIVE. It worked because the tasks to write this script was:

• small in scope
• clear technical design

It built he tool for me in a few seconds which would have taken me more time just typing it.

An important remark however, is that if you know what would be the "Best tool for the work", this would also tremendously improve the speed and quality of the result.

I asked the Agent to build the same tool twice. First in bash, second using babashka. And for my specific need, not only it was a lot faster to build the tool using babashka, but the result was clearly superior both in design and quality as well as efficiency.

(+) PR Reviewing

I think a nice use case of AI Assistant is to ask it to generate a review of your PR locally prior to send it to show it to your team.

• about 10% is plain wrong and MUST be ignored
• 70% not useful, but could be ignored,
• 20% are good recommendations.

While 20% is not much, this is still a net positive. Personally I feel that using AI just for review would already be a good reason to add them to your tool-belt.

(++) Asking specific technical details about your own project

Using RAG + Clojure-MCP to search and discover the details of your Project, this ended up being very useful.

I work on a huge base code. We created a full platform from scratch that contains hundreds of technical details. Some of them are long forgotten in some documentation, and some were not even cleanly documented due to time pressure during the delivery.

Still I could ask these very specific questions and got a clear answer. Of course, as you should never trust the system fully, I asked for the source code and documentation to be able to verify the answer. And it worked perfectly.

Typically I could ask "What is the HTTP Header to use for this specific feature?" and it looks at the code and returns the value with a small documentation and pointer to the sources.

(+) Writing doc

While everything must be proofread because you cannot fully trust the Agent, this generally gives a good first pass overview and can generate a documentation of mediocre quality. If you want a good documentation it will need a lot more time. But I still give a positive outcome as existing and bad documentation is still a net positive comparatively to no documentation.

(-) Writing tests

In my experience, asking these agent to write tests can either be a net positive or a full net negative were I had to delete all generated tests. So I wouldn't recommend using AI code generation for writing advanced tests cases. But I feel this is fine for very specific small functions. And even there, you really need to be cautious about passing tests that are not useful at all and just give a false sense of safety.

Sometime it is just better to write the tests, at least the cases but not the boilerplate, yourself to be sure you are testing the correct thing.

(++) Familiarize with foreign code

The ability to generate a PROJECT_SUMMARY.md as suggested by the Clojure-MCP tutorial, proves that these tool can really help grasp a new project. It's structure, the generic ideas, etc…

This is not totally perfect, but I got impressive results, so this count as NET POSITIVE.

Conclusions

With this new tryout of the AI tools I could discover tasks for which they are useful. In terms of productivity, I believe their benefits depend tremendously on the type of work you assign them. I feel they have a place as a daily-use tool, particularly for pre-reviewing your code and helping you write documents.

To be effective you need to:

1. Use something at least as efficient as Claude 4 Sonnet; so an Agent with Clojure-MCP and RAG support.
2. Be conscious about the scope and complexity of the task
3. Be able to provide precise technical specification of the task
4. Always be conscious (evaluate and monitor) the time it would take to complete the task manually versus the time spent supervising the automated tool.

If you familiarize yourself with these agents, really try Clojure-MCP. It is a game changer and that provide a pretty huge advantage to Clojure comparatively to other programming languages.