The dev is the only tool without an API
<p class="lead">The dev is the only tool without an API.</p>
A dev opens Jira to find out what to do.
They find the right repository among the ten they have open this week.
They open their IDE and pull the branch.
They jot down two or three things in a Notepad tab: what they mustn't forget, what they've understood about the ticket.
They open VSCode with an AI to write the code.
They launch Docker to run the app locally.
They open the browser to check that it works.
They run the tests in another tab.
They push, open the MR on GitHub.
They check Jenkins to see if the CI passes.
They go back to Jira to update the ticket.
Eleven steps. Six tools. Twelve tabs. And none of them knows what the others are doing.
Every tool is good. The whole is not.
None of these tools is bad.
Jira does its job very well. GitHub too. Docker too. Jenkins too. Git too. VSCode too.
The problem isn't the quality of the tools. The problem is that they don't talk to each other.
The ticket knows there's a branch. The branch knows which repo it lives in. The repo knows there's an MR. The MR knows there's a CI. The CI knows there's a test that failed.
But nobody connects all that. Except the dev, in their head.
The ticket is in Jira. The branch is in git. The repo is in the IDE. The MR is on GitHub. The CI is in Jenkins. The failing test is in a terminal tab. The ticket context is in a Notepad tab.
Six places. One brain to connect them all.
What nobody measures
This time doesn't show up anywhere.
Not in a daily. Not in a burndown. Not in an estimate. Not in a sprint review.
Yet it exists. It's even the most exhausting part of the day, the thing that breaks focus the most, the thing you can't bill, the thing you can't explain to a manager who asks why a two-hour task took four.
It's not wasted time. It's connection time. And nobody counts it.
Code no longer has value in itself
For twenty years, a dev's value was their ability to write code. To know the syntax, the patterns, the frameworks, the libraries. To solve problems by assembling lines.
That's no longer true.
Today, it's AI that writes the code. On the dev's directives. The dev describes what they want, AI produces, the dev reads, corrects, validates.
Code itself has become a commodity. It's produced in seconds, in any language, in any framework, at a perfectly acceptable level of quality.
What has value is what remains around it. Understanding the need. Deciding on the architecture. Arbitrating between two approaches. Connecting the ticket to the branch, the branch to the repo, the repo to the CI, the CI to the failing test. Keeping track of the work in an environment that was never designed for that.
A dev shouldn't waste their time connecting their tools. They should write code with AI, and keep their attention for what matters.
What connecting would mean
Connecting isn't replacing. Nobody wants to replace Jira with something else, or GitHub, or Docker, or Jenkins. Teams have spent years configuring them, training people, writing processes around them. These tools work. They're installed. They're known.
Connecting means making them talk to each other at last.
Knowing that a Jira ticket has a key, and that this key is in a branch.
Knowing that this branch lives in a specific repo, and which repo the dev should open.
Knowing that this branch has an MR, and that this MR has a CI.
Knowing that this CI has a test that failed, and which file that test concerns.
Knowing that this file was modified in a commit, and that this commit is linked to an AI session.
Knowing that this session produced a report, and that the report mentions the same ticket.
None of this is magic. It's just links.
But today, no tool maintains them. So the dev maintains them, in their head, tab after tab, all day long.
What Mergerie does
Mergerie doesn't replace any of these tools.
It doesn't ask you to leave Jira, or GitHub, or Docker, or Jenkins. It doesn't ask you to change IDEs, AI CLIs, or forges.
It plugs into what already exists, and it connects.
It knows that a Jira ticket has a key, and that this key should end up in a branch. It knows that a branch lives in a specific repo, and which repo to open. It knows that a branch has an MR, that this MR has a CI, that this CI has a test that failed.
It also knows that two or three things are worth noting, and gives them a place to live, linked to the object in question, instead of a Notepad tab that will vanish on the next restart.
It doesn't produce code on behalf of the dev. It doesn't make decisions on behalf of the dev. It doesn't merge on behalf of the dev.
It connects. That's all. But it's exactly what nobody does today.
The dev is the only tool without an API.
Mergerie is their API.