Jir’Ah, the Paperwork Deity: Why Jira Is a Shitty Agile Tool

Some tools aren’t just neutral—they make it easier to do the wrong thing faster. Guns, sure. But also Jira.

Jira doesn’t kill agility outright. However, it certainly helps it bleed out slowly while drowning in unresolved dependencies, custom fields, and admin requests.

Let me explain.

Guns Don’t Kill People. Jira Does.

The NRA loves to say, “Guns don’t kill people. People kill people.” But that’s disingenuous. Guns make it really fucking easy to kill people. That’s what they’re designed for.

The AR-15 isn’t popular because it's ergonomic. It’s popular because it could fire a metric shit-ton of rounds in seconds. Even when that feature got nerfed, bump stocks and conversion kits filled the void. And when someone used one to spray 1,000 rounds into a crowd in Las Vegas? Nobody blamed the spreadsheet.

So let’s drop the pretence. Tools shape behaviour.

Which brings us back to Jira.

The Two Types of Tools

Broadly speaking, digital tools fall into two buckets:

• Systems of record – suitable for governance, audit trails, and covering your arse.
• Systems of action – good for actually getting shit done.

Jira wants to be both. It ends up being neither.

Agile Manifesto vs Atlassian Admin Panel

The Agile Manifesto says:

“Individuals and interactions over processes and tools.”

Jira says:

“Please select a Component, enter Story Points, set the Fix Version, assign the Epic Link, fill out Acceptance Criteria, update the SLA field, and tag three unrelated people. Also, the issue type is wrong.”

Agile was sticky notes, index cards, and conversations over coffee. Jira is a permission-locked process graveyard.

XP, Shoeboxes, and Why Less Is More

Back in the old XP days, we had a wall. On it? Cards. Real ones.

The story lived in the conversation—not the card. And when an auditor once asked Mike Cohn for proof of requirements? He handed them a shoebox full of index cards and said, “Here. “

That, plus tests, plus trust. Done.

Contrast that with Jira:

“User should be able to click the blue button to submit a form and receive toast notification.”

What user? What need? What conversation? What trust?

Gone.

Jira as BRS-by-Stealth

Too often, Jira becomes a Business Requirements Spec in drag:

• A thousand sub-tasks
• Wordy descriptions no one reads
• “Stories” that are really just implementation notes

It’s tempting to treat Jira as a dumping ground for everything you should’ve said to a developer but didn’t.

And once it’s done in the system, it’s gospel. No take-backs. No evolution. Just workflow inertia and a passive-aggressive trail of comments.

When Tools Become Gods

If Terry Pratchett had written a Discworld novel about agile development, he might’ve said:

“Jir’Ah, the Paperwork Deity.

An eldritch being made of ticket IDs and unresolved dependencies. Summoned via incantations like ‘please update the epic link’ and ‘can we add a custom field for that?’”

It’s not just satire. Jira demands compliance.

It turns every workflow into a gauntlet of checkboxes. Even cancelled work needs to move through every column to be declared dead. And eldritch deity forbid you change the workflow—Jira’s friction will ensure you don’t.

Trust and Tactility

There’s also something human and beautiful about physical tools:

• The dopamine hit of dragging a sticky note to DONE.
• The visibility of a cluttered board is something that everyone sees.
• The ritual of tearing up cards and starting fresh.

You can’t replicate that with Jira. No amount of dark mode and rainbow tags will save you.

My First Failure (AKA: Agile by Template)

I made this mistake too. In 2005, I thought slapping the agile template onto Team Foundation Server would magically transform my team.

It didn’t. Because agility isn’t something you install, it’s something you practice. And the wrong tools get in the way.

So What Do We Use Instead?

Tools like Miro or Mural are built for agility:

• Infinite whiteboards.
• Tactile card movement.
• Embedded diagrams, retros, mind maps, and team norms.
• Instant changes. No admin tickets required.

They’re not perfect. But they can become the living, breathing artefact that tells the story of all the work the team does. They don’t demand that you fit your process into their box. They let your team evolve—and they capture that evolution as a living, breathing system of record.

Tools aren’t Neutral

Taichi Ohno once said that a team not updating its Kanban is stealing their salary. Translation? Your board should be yours—alive, responsive, changing with your needs. If a tool holds you back from evolving your methods, it’s not neutral. It’s a constraint. A bureaucratic parasite.

Jira Doesn’t Kill Agility—But It Sure Helps Bury It

You can try to improve Jira. Add plugins. Reduce required fields. Hack around it with Slack integrations and sprints-of-sprints and all that jazz.

But you’re still using a screwdriver to hammer in a nail. Maybe it’s time we stopped worshipping the paperwork deity. Perhaps it’s time we built our own altars.

Miro. Mural. Whiteboards. Shoeboxes. Something—anything—that makes collaboration easier, not harder. Because Agile isn’t about tools. But the wrong tool will fuck you up just the same.