claude code for project management: when your AI understands your backlog better than you do

by Ray Svitla

project management tools are supposed to help you ship. instead they mostly help you perform the theater of productivity.

you spend 20 minutes formatting a ticket that takes 5 minutes to implement. your sprints are full of stories that nobody actually wants. your backlog is a graveyard of ideas that sounded good in a meeting but will never get built.

and somehow, despite all this process, nobody knows what anyone is working on.

Claude Code with MCP integrations won’t fix bad project management. but it can eliminate the bullshit overhead that makes good project management impossible.

the ticket creation tax

creating a good ticket is work: → clear title → description with context → acceptance criteria → proper tags and priority → linked to epic/milestone → assigned to the right person

by the time you’ve formatted all this, you could have just built the thing.

most people respond to this tax by writing terrible tickets. “fix the bug” with no other context. “improve performance” with no metrics. “add feature” with no specification.

then three months later someone asks “what does this ticket mean?” and nobody remembers.

here’s the Claude Code approach:

you: “I need a ticket for adding password reset via email, should use sendgrid, needs rate limiting, and should work with our existing user model”

Claude Code (via Linear MCP): → creates the ticket → generates proper acceptance criteria → adds relevant tags → links to related tickets → formats everything correctly → adds it to the current sprint

30 seconds instead of 20 minutes. and the ticket is actually useful.

sprint planning without the meeting

sprint planning meetings are simultaneously too long and not detailed enough.

two hours of discussion to decide which tickets go in the next sprint. half the estimates are wrong. half the dependencies are missed. everyone leaves exhausted.

alternative approach:

Claude Code reads your backlog, understands your team’s capacity, knows your recent velocity, and can draft a sprint plan.

“plan a two-week sprint, prioritize auth improvements, avoid anything that depends on the API rewrite, max 40 story points, balance between frontend and backend work”

you get a proposed sprint in seconds. then you review it, adjust the priorities, move a few things around. 20 minute review instead of 2 hour meeting.

the meeting becomes “do we agree with this plan?” instead of “let’s build a plan from scratch while everyone watches.”

backlog grooming that doesn’t suck

your backlog is a mess. 300 tickets, half of them outdated, a quarter duplicates, most with zero context.

nobody wants to clean this up. it’s boring. it takes hours. and you’ll probably miss half the issues anyway.

Claude Code can help:

“analyze the backlog, identify duplicate tickets, flag anything that references deprecated features, group related items, and suggest what can be closed”

it won’t get everything right. but it’ll do the boring pattern matching part. you just review and approve.

same logic for ticket hygiene. “find all bugs that haven’t been updated in 6 months and either close them or add a ‘stale’ tag” — done in seconds.

dependency mapping: the thing humans hate

every project has dependencies. “we can’t build X until Y is done.” “this blocks on the design team.” “waiting for API access.”

tracking these manually is hell. dependency graphs get out of date. blockers get forgotten. critical path analysis happens never.

Claude Code can map dependencies by reading ticket descriptions and comments. then it can tell you:

“these three tickets are all blocked by the auth refactor” “this epic has a circular dependency” “if the API work slips, these 8 tickets will miss the deadline”

you could do this manually. but you won’t. Claude Code will.

status updates without the standup

daily standups are supposed to be quick sync-ups. they turn into 30-minute status reports where half the team zones out.

what if your status update was automatic?

Claude Code reads your commits, checks your assigned tickets, looks at PR comments, and generates a status update.

“working on ticket ABC-123, blocked waiting for design review on the modal component, planning to start ABC-124 this afternoon”

you review it, adjust if needed, post it. 30 seconds.

now the standup can be what it should be: discussing blockers and coordination, not reciting what you did yesterday.

the jira problem: when process became performance art

jira is powerful. it’s also a perfect example of tools that optimize for management visibility over team productivity.

you have custom fields for everything. workflows with 15 states. mandatory fields that nobody cares about. and half the team’s time goes into updating tickets instead of shipping code.

Claude Code can be your jira translator. you work in plain language, it handles the jira ceremony.

“I finished the feature, QA approved it, it’s ready for release” becomes: → ticket moved to “ready for release” status → QA approval field updated → release notes auto-generated → stakeholders notified → next ticket auto-assigned

you’re interacting with the project, not with jira’s UI.

estimation: still terrible, slightly faster

estimation is famously hard. sprinkle in some AI assistance and it’s… still hard. but at least faster.

Claude Code can look at similar past tickets, check team velocity, factor in dependencies, and suggest estimates.

will they be accurate? probably not. human estimates aren’t accurate either.

but you’ll get a starting point faster, and you can spend the saved time discussing the actual uncertainties instead of arguing about whether something is 3 points or 5 points.

milestone tracking: automated but not annoying

milestones exist so managers can answer “when will this ship?” without asking you every day.

but keeping them updated is work. tickets move around, estimates change, priorities shift. your roadmap is always slightly out of date.

Claude Code can monitor milestone progress and update you when things slip:

“milestone Q1-launch is at risk: 3 high-priority tickets are still in backlog with 2 weeks remaining”

proactive tracking without the overhead of manual updates.

cross-team coordination: the hardest problem

most project management tools are terrible at cross-team work. your team uses Linear. the design team uses notion. the marketing team uses monday.com. everything lives in silos.

MCP servers can bridge these tools. Claude Code can read from multiple sources, understand dependencies across systems, and keep things synchronized.

“when the Linear ticket for the new feature is done, create a notion page for design review and a monday task for marketing prep”

this is the kind of glue code humans hate writing. perfect for automation.

when automation makes things worse

here’s the trap: every automated update, every auto-generated ticket, every synchronization creates notification noise.

too much automation and your team drowns in alerts. the tools become noisier than the manual process they replaced.

the skill is choosing what to automate:

→ automate: repetitive data entry, status synchronization, dependency checking → don’t automate: decisions, priorities, human communication

automation should reduce cognitive load, not replace thinking.

the meta problem: optimizing the wrong thing

here’s what bothers me about most project management: it optimizes for tracking instead of shipping.

perfect ticket formatting doesn’t ship features. detailed burndown charts don’t ship features. six layers of approval workflow don’t ship features.

Claude Code can help you track things with less overhead. but if your process is fundamentally broken, automating it just means you’ll fail faster with better metrics.

the hard questions aren’t “how do I create tickets faster?” but “why are we creating so many tickets?” and “is this process helping or just creating work?”

AI can’t answer those questions. only you can.

the future: post-ticket project management

maybe tickets are the wrong abstraction entirely.

what if instead of tracking work through jira, you just describe what you’re building and the system figures out the tasks, dependencies, and assignments?

we’re not there yet. but we’re close enough that it’s worth thinking about.

for now, use Claude Code to reduce the friction of current tools. tomorrow, maybe we’ll have better tools that don’t need as much friction-reduction.

what part of project management feels most like pointless overhead to you? and if you could automate away one PM ritual, which would it be?

Ray Svitla stay evolving 🐌