Why I No Longer Log Into Jira

The MCP link still talks to Jira. The agents read the stories. The UI just stopped being where the work happens.

The last time I opened Jira on purpose, I was double-checking a field name. The agents had already read the story, pulled the acceptance wording, and started the branch while I was still thinking about coffee. I stared at the board for maybe thirty seconds, closed the tab, and went back to the terminal.

That was months ago. The Model Context Protocol link still talks to Jira; work still lands in tickets when someone outside the team needs a paper trail. The part I stopped doing was treating the UI like the center of gravity.

Once the integration was live, the uncomfortable question stopped being “how do we track this?” and became “what are we tracking, exactly?”


What the UI was actually for

Most teams assume Jira is where work lives. It isn’t. Jira is where humans coordinate when understanding the work is slow, expensive, and easy to lose.

Epics, story points, sprint velocity, fixed two-week boxes. Those concepts are not mystical. They are scaffolding for uncertainty and handoff. They exist because people forget, disagree, and get booked solid, and the backlog is a memory prosthesis with a burn-down chart taped to the side.

When an agent can pull the story text, thread the comments, and execute without you babysitting the grid, the prosthesis matters less. The “single pane of glass” becomes a fax machine in a Slack-first company. It still works. You just stop walking to it.

The failure mode isn’t obvious at first. You automate the busywork and keep every ceremony intact. Then you notice you are grooming and pointing tickets for throughput you no longer have.


The pace underneath the board

Here is the shift I could not unsee once agents were in the loop.

Work that used to justify an epic now fits in a two- or three-line shirt-size story. A “sprint” of effort can evaporate in an afternoon. Priority doesn’t hold still long enough for a fortnightly meeting to be the source of truth. By the time you have polished slides, the bottleneck has already moved twice.

So we stopped pretending two-week planning was the clock. We moved to a now / next / later / bullpen board that matches how fast decisions actually flip. “Now” is thin on purpose. “Later” is allowed to be fuzzy because most of it will never graduate. The bullpen is where things go when they are real but not entitled to attention yet.

If it comes back, it mattered

No Linear shrine. No endless groomed queue. No holiness attached to story points. If an item matters, it surfaces again. If it doesn’t, it dies quietly and nobody schedules a funeral. That is not chaos. It is deliberate intake pressure. You are forcing the work to re-earn its slot against everything else that could happen this week.

The tradeoff is emotional. People like the comfort of a full backlog. It feels like control. What it often is, is deferred triage with cosmetics.


When the ticket costs more than the bug

There is a crisp economic argument hiding under the politics.

The cost of fixing an issue and the cost of understanding it are converging. Agents compress implementation and first-pass investigation. Writing the ticket, routing it, debating priority, assigning points, and waiting for a sprint boundary can easily consume more attention than the patch.

At that point the ticket is not inventory. It is friction dressed as hygiene.

With MCP in the middle, the tracking layer can be delegated the same way the diff can. The machine can read Jira, write Jira, and stitch context from the same fields you used to copy by hand. “Managing the work” and “doing the work” stop looking like two different jobs occupying two different browsers.


This is already happening

I am not forecasting a brave new process for 2030. I am describing what shows up once delivery outruns the spreadsheet you built last year.

You see it in small teams that never loved enterprise tooling. You see it in shops with dozens of engineers who quietly admit their “source of truth” is a channel, a doc, and whatever the agents touched last. The pattern has a rude name if you need one: post-backlog engineering. The backlog stops being the spine. It becomes an export format.

Ceremony scaled to human coding speed does not survive human+agent coding speed without turning into cosplay.

That does not mean zero accountability. It means you stop mistaking artifact count for clarity. Auditors and customers still get receipts. What changes is where you spend your attention while the receipt writes itself.


A harder book problem, in plain terms

If you have been thinking about requirement bottlenecks in the AI era, this is the same pressure from a different hallway camera. When generation is cheap, vague intent is expensive. When delivery accelerates, the organization either rebalances its process or it entertains itself with rituals. I unpack the organizational side of that rebalancing in Stop Implementing AI, in the chapters on requirement bottlenecks and on process changes when delivery speeds up.


What to do next

Pick one delivery slice your team trusts, wire MCP (or your equivalent) so agents can read the stories without you shepherding tabs, and run a month with your planning horizon visible on a now / next / later board instead of a packed sprint backlog.

Then ask a single question in retro: what meeting or field existed only because humans were slow, and what survived because the work genuinely needed it?

Whatever fails that test is not process debt. It is costume. Take it off.

More field notes are in the blog archive.