How I Keep My Code up to Date With Zero Effort With Claude

Dmytro Taranov — Fri, 01 May 2026 17:07:27 +0000

Like most developers, I’ve always been stressed by the sheer volume of dependencies. A typical project has 50 to 100 third-party libraries, and they are constantly changing. How are you supposed to track all of them?

I used to obsess over this because it was eating up a massive chunk of my time. But the worst part? When one library falls so far behind that it starts conflicting with everything new you try to plug in.

What’s the solution? Manually check and update them every day? Sure... there are plugins and tools, but when you’re under pressure, in active development, or rushing a feature, maintenance isn't your first, second, or even third priority.

And then, one day - BAMMMMM**** You add a simple dependency, and everything is incompatible (Rage moment).

So, let’s get into how I actually solve this problem...

I’ve seen a lot of people online using AI for these kinds of solutions, and honestly, I wanted in. It seemed like a perfect use case. On the surface, the task is simple: check a list of libraries, find the new versions. It’s exactly the kind of thing an AI should be able to handle effortlessly.

I decided to give it a shot with Claude

But as soon as I started, I hit the reality of how LLMs actually work. If you just ask an AI to find updates, it starts hallucinating version numbers that don't exist because its training data is static and might be stale. I tried letting it browse the web, but it just got lost in the noise of old documentation and random GitHub issues.

That’s when I realized that if I wanted this to work for a professional-grade project, I couldn't just 'ask' the AI... I had to build a proper architecture around it.

The Architecture: My Zero-Effort Pipeline

I decided to use the new Claude Routines (they just released it, and it's a game changer because it allows you to set up recurring tasks, even if your PC is off). I have mine scheduled as a routine that triggers every Friday morning.

For the data, I’m using Context7 as my source of truth (If you’re not familiar with it, it’s a tool you can plug into Claude that acts as a real-time repository for the latest library versions). Unlike Claude’s internal training data, Context7 is constantly updated with the newest releases.
My setup looks like this:

Let’s look under the hood at how I actually implemented this.

I started by taking my dependency file and asking Claude to convert it into a clean Markdown file. I specifically told it to generate a table with only two columns: the library name and its current version.

Why this approach? Because it’s much easier for Claude to parse a structured Markdown table than my raw source files, which are cluttered with configurations, plugins, and other boilerplate code.

I then created a dedicated repository just for this Markdown file. This keeps the environment clean and ensures the agent focuses only on the data that matters.

Here is what the final result looks like:

The last piece of the puzzle

he last piece of the puzzle was setting up Claude Routines on that specific repository. I added Context7, configured the scheduler, and spent some time crafting a prompt that would actually deliver.

The goal was simple: Claude needs to read that Markdown file inside repo, run every single library through Context7, and then open a Pull Request in that same repo with an updated table (separate file). This new table has four columns:

library name
current version
new available version
status

But it wasn’t easy. I ran into two major issues during testing:

The 'Lazy Agent' Problem: Claude would check 8 or 10 libraries and then just stop, thinking the job was done.
The Tool Bypass: Sometimes it would ignore Context7 entirely and try to find versions using its own stale data or random web searches.

After a lot of trial and error, I finally found the right prompt engineering to force it to process the entire list sequentially and stay strictly within the Context7 'Source of Truth.'

For the output, I decided that this dedicated repo was the best place to store the results. I instructed Claude to name the new file with the current date and open it as a PR.

And here is the result:

Conclusion

Now that this is running, I’m honestly satisfied with the result. The best part? It works completely independently of me. Even if my computer is off, the process just happens. It’s a great feeling to wake up on a Friday and see the work already done.

All I have to do is check the file when it’s ready. But honestly, do I even need to check file? Probably not.

While setting this up, I noticed that Claude Routines has a lot more triggers than I initially realized. Right now, I’m working on taking this to the next level: a setup where the libraries are updated directly in the code, fully automatically. I think I’ve already found a very solid solution for this.

I’ll share exactly how I did it as soon as the implementation is finished.

If you want to dive deeper or replicate this exact setup for your own projects, check out the full video I’ve posted on YouTube. I’ve put together a very simple, step-by-step guide there. If you follow along, you can have this entire system up and running in about 5 minutes: https://www.youtube.com/watch?v=tscsoX-Rvj0
If you’ve already read the background and just want to dive into the implementation, feel free to skip the intro and start the video at 1:18

Thanks for reading!

How I Automate Jira Tickets Investigation using Claude Code & MCP

Dmytro Taranov — Sun, 19 Apr 2026 15:03:06 +0000

As a software engineer, I hate context switching. Investigating a Jira ticket usually means bouncing between Jira for the context, Confluence for the high-level logic, the Codebase for the actual implementation, and finally Slack to ping the reporter about blockers/additional questions.
It takes time, breaks flow, and is incredibly tedious. So, I decided to automate the entire process using Claude Code and MCP.

I connected Claude to my Jira, Confluence, and Slack using MCP (Model Context Protocol).
Now, my day starts simply: I ask Claude for a list of my active Jira tickets and give it a command to investigate a specific one.

In about 2 minutes, Claude does the heavy lifting. It either prepares a complete implementation plan, or it compiles a list of blockers and clarifying questions that prevent me from moving forward.
I just start coding session If the plan is ready and there are no blockers. If there are blockers, Claude automatically drafts and sends a Slack message to the ticket reporter asking for clarification.
You can see the workflow diagram below:

Everything starts with asking Claude: "Which tickets do I have in Jira?"

Claude uses the Jira Explorer Skill to hit the Atlassian MCP and pull my current tasks.

Once the ticket is selected, I give the command: "Investigate this ticket and prepare an implementation plan."

This triggers the Knowledge Researcher Skill. The magic here is the strict order of execution. I explicitly force Claude to search Confluence first, and only then look at the Codebase. Confluence usually contains the high-level logic and API specs. If the agent jumps straight into the code, it scans blindly, wasting both time and tokens.
If all the information is there, Claude gives me a ready-to-use, step-by-step coding plan. But during the research, Claude might realize we are blocked (e.g., a missing payload structure or an undefined API endpoint). It will immediately stop and prepare a list of these blockers.

Since I can't start coding, I tell the agent: "Find the reporter of this ticket and send these blockers to them on Slack."

Claude triggers the Slack Researcher Skill, finds the right person via Slack MCP, and drafts a highly professional message explaining exactly what is missing.

I’ll be honest, getting here wasn't without its challenges. I had to fine-tune the agent and figure out these strict rules through a lot of trial and error to prevent token drains and hallucinations. But right now, it works flawlessly.
Anyway, if you want to see how this actually works in reality, I recorded a step-by-step video on YouTube with real example:

If you want to skip the overview and example and dive straight into the exact prompts I wrote, and how I configured the custom skills and hard rules, you can jump directly to [05:22]