Tasks as Code: Move Your Tickets into the Repository

Life used to be simple.

Client wrote down what they wanted, programmers translated it to code, testers validated that against what clients had written down.

Now we have tickets, where BA's (but most of the time developers, really) write down the lore that is told in numerous meetings.

Tickets are supposed to be ephemeral but never really aren, that's why we keep some of the lore in Wikis. Except Wikis are good for text, not so good for everything else, that's why the lore spreads to Figma, Excalidraw and Google Sheets (if you are lucky, xls documents on Sharepoint if you are not).

Now we start coding. Some of the lore get's solidified into code, which is good, some turns into tests which is good too, if you are lucky some turns into formal spec a tool can check.

But, there is always something left that gets spread evenly - more or less - across regular comment, doc comments, commit messages and various md files, most notoriously the README.md.

Which brings me to user documentation which again is often spread over the whole oeuvre of documents and systems we mentioned. Not to mention the confusion of most documentation about its intended target group. Is it for user documentation for the user really? Rarely!

Oh and then changelog that really wants to be release notes, but isn't, at least not entirely. Which is generated automatically, but isn't, at least not entirely.

I'm curious in what is the value of this kind of solution. Having run my own software factory for just a week or two, I'm at well over 1000 agent jobs (; a more flexible variant of what a swimlane on a scrum board represents). If I did a year of having the factory running, I would end up with 10~50K tickets across my repo's, then what? Do you keep them forever?

I don't follow what the value is in putting all that in a Git repo, let alone putting everything through a cycle of git/commit/push. The source of truth is the code, so if you're capturing this for additional context about why things were built, then you may as well follow the path of Entire; former GitHub CEO's company, and record the entire agent session to get the full context.

Just shooting from the hip, I don’t see this scaling super well. As the number of tickets grows you’ll need some way to efficiently track WIP, filter tickets by status, etc. Jamming it all into LLM context won’t do, and relying on the agent harness to automatically sort it out will be unreliable.

So you’ll eventually want a more formal way to track and query everything, and to route the coding agents through that API to ensure consistency and reliability. At which point you’ve basically just reinvented the ticketing system that you originally sought to eliminate. Only it might still be flaky because every source control branch introduces a secondary source of truth for ticket status.

This doesn’t work in an org with stakeholders that don’t have access to the code base, I.e. most of the other company. You still need tickets, a way for stakeholders to follow, update, etc. those tickets, and a way to prioritize the tasks those tickets represent.

Tickets change faster than code. Having to create a PR to update a ticket sounds like a bureaucratic nightmare.

While I understand the appeal of having local files that agents can read, I think the best way to do it might be pulling the needed files from a database. By its nature, tasks are linked in relationships of parenthood and sequence, so databases are naturally suited for storage. Plus, they need ownership relations. So, something like Jira but please oh god not Jira, where you can pull a subset of the DB (for example a project) locally and have some script generate the needed files (requirements) from what would be a Jira description.

Relational databases exist for a reason. Every effort that starts with “I really want to use this tool so let me shove a use case into it” always ends in disaster. Git has a purpose, and building an information management system is not one of them.

To start, how are you going to run queries on this bug tracker? How are you going to make sure it stays up to date for everyone at the company with sub-second latency? How are you managing access control? How do you keep the size under control over time?

When someone sells hammers, they want you to hammer screws. Typemill is a document product and naturally, they want you to use that. It looks very polished and nice though, shame not packaged for distro though.

These kinds of things are an EM’s wet dream. Especially an EM who knows they are not adding anything to the team but are capable of putting together a slide, mentioning “productivity reached X” without mentioning the baseline, and still being able to sell that improvement.

Tangibly related - I use Linear for ticket management and I'm in love with this. After being defiled by Jira in my $dayjob, I couldn't believe I'll find a ticket management app I would love so much I literally advertise for free.

I'm not a beads user - but it rather brilliantly solves a lot of problems in this space

Terrible idea because these two artifacts (ticket and code) have different lifecycles, different participants, different rates of churn, different needs from a reporting perspective, and different rules/workflows.

Tickets being external to source decouples the systems, parties, and lifecycles.

Nah. There's a manager at my company that's pushing this, and it sucks for pretty much everyone except him. I suppose it's fine if you're delegating sprint management to AI agents, but everyone except the manager is going to be using this tool to manage sprints.

"AI coding agents work best when everything they need lives in the repository" honestly not true, they work best if they have all the information up front, local filesystem is pretty cheap path to that.

Better path is an orchestration agent that composes a short spec with the slice of the details for a slice of the work. Tickets end up being too verbose as people try to cover every potential aspect / use LLMs to generate them.

I kind of fear this would cause agents to get lost in previous outdated context, ultimately wasting time and tokens.

Yes! There are some existing projects and posts on the idea of tickets in-the-repo.

Usually the problem is that it's not very friendly for Product Folks and SMEs so I've been working on a local first, git backed project management and documentation tool (Think Jira and Confluence).

So as to not hijack this post, I won't paste a link here (not to mention it's ready for prime time yet) but send me a message if you're interested (it's open source and visible so it's not too hard to find either)

It's a very bad idea! ticket managers do more than just store ticket text! also duplicating a ticket text in the repo it's just wrong.. then why don't you put your db data into the repo too ?

A lot of the tools we have to use are designed for meat proxy's (JIRA etc...) yes, you can allow the agents access to the task repo via api or MCP, but at the end of the day, the tool starts to become the bottleneck, Iike the idea of putting the tasks and issues into git, it means all info for why a change was made is in one place, accessable forever, just need to expand agents to non-software dev world.

I have a rest API client for linear and the robot can read the ticket this way ? And comments made by Products and Design folks.

Nope, you're breaking Git history with that.

You should think about what your history represents. Just move the task manager somewhere else and track it there.

I actually did something similar with my team a few months ago. We exported all our confluence articles and all our Jira tasks into Obsidian and then made a few simple extensions to replace the functionality we needed from them (sharing links to pages, ability to make comments on pages, creating new tasks, using bases as a way to organize our todo tasks, use git for file history), for a DevOps team of 4 it has gone very well and it has made an massive improvement for giving our AI agents up to date docs on whatever we're working on.

[flagged]

[flagged]

[flagged]

[flagged]

[flagged]