A markdown backlog for AI coding agents
A markdown backlog for AI coding agents works for one person. Shared decisions and missed intake break it. Keep the rules file short and put each decision on the card.
A markdown backlog for AI coding agents is enough when it is you and one agent. Read the file at the start of the session, tick the line when the work is done. It holds. It breaks once the requests show up somewhere else, and once more than one person and more than one agent share the repo.
The file worked, for one person
For a while I've just kept all my features and my backlog in a markdown file in the repo, and had the agent read it at the start of each session so it knew what to work on and could tick things off when it was done. Honestly it worked a lot better for me than I thought it would.
The only issue with my system so farthough has been that once I started getting more real users, bug reports and feature requests would come in through emails or on Discord, and they wouldn't make it into the file unless I copied them in, which I'd usually forget about. I'd forget about the changes people actually wanted and just end up making random things instead.
I also found that it got pretty messy as the file got longer. I was still deciding what to work on by just picking whatever I felt like that day, would get lost in it for hours, and the notes about why we'd made certain decisions ended up buried somewhere in the middle where I'd never find them again.
I'm still not sure where the line is though. If you've been building using Cursor for a while, did your markdown file hold up, or did you end up moving to something else?
u/Skyfall106 posted that on November 15.
For a while I've just kept all my features and my backlog in a markdown file in the repo, and had the agent read it at the start of each session so it knew what to work on and could tick things off when it was done. Honestly it worked a lot better for me than I thought it would.
Yup. One person, one agent, the file is the queue. I would not tell you to throw that out.
Then the two holes, in their words.
bug reports and feature requests would come in through emails or on Discord, and they wouldn't make it into the file unless I copied them in, which I'd usually forget about.
the notes about why we'd made certain decisions ended up buried somewhere in the middle where I'd never find them again.
The rest of that post is a tool. I have not used it, and I am not describing it.
u/Trick_Candy9796 wrote:
The markdown file held up fine until the input side broke. What fixed it for me was not letting the .md be the source of truth for incoming work.
The rest of that comment is a tool. I have not used it, and I am not describing it.
u/NanYUJun wrote:
The markdown file held up for me until about the same point, and what broke wasn't the length so much as the input side.
u/Creepy_Craft_9194 wrote:
A markdown backlog can stay useful if it's an execution queue rather than the whole product memory.
Yup. Keep the file if it is the queue for the session in front of you. Stop using it as the place every request and every old decision has to live.
Several agents, and the decision drifts
Curious how engineering teams running multiple coding agents are handling decisions made across people, sessions, and tools.
For example: an architectural decision gets made in a meeting or one engineer’s Claude Code session, then another engineer’s agent makes a change that contradicts it weeks later.
Is this actually causing rework or bugs for you, and roughly how much time is it eating? How are you handling it today repo rules, shared memory, code review, something homegrown? If you built something internal, did it hold up?
Especially interested in hearing from CTOs and engineering leads running parallel or long running agents. Would love to compare notes.
Oana Olteanu posted that on November 16. She is a VC, and she is asking founders and engineering leads. This is not a study.
Curious how engineering teams running multiple coding agents are handling decisions made across people, sessions, and tools.
For example: an architectural decision gets made in a meeting or one engineer’s Claude Code session, then another engineer’s agent makes a change that contradicts it weeks later.
How are you handling it today repo rules, shared memory, code review, something homegrown? If you built something internal, did it hold up?
That second line is the failure. The decision was made. It lived in a meeting, or in one Claude Code session. Weeks later another person's agent does the reasonable thing, and the reasonable thing contradicts the call. A shared markdown file does not stop that. The next session never opens the paragraph in the middle.
Asrar posted the same day:
I think one of the biggest problems with multi-agent development isn't writing code.
It's keeping decisions consistent.
And:
The question is whether existing tools like AGENTS.md and documentation are enough.
Kai wrote: "They work alone. None of them knows what the others are doing, so I end up switching windows and carrying information between them by hand."
Yup. If the decision only exists in your head, you are the bus between the sessions. That does not hold once two people are doing it.
A markdown backlog for AI coding agents stays the rules file
Keep AGENTS.md, or CLAUDE.md, short. How tests run. Which files to leave alone. The shape of a commit. Rules that apply to every task. Every session should read that file, and it should not grow a feature list or a diary of old calls.
The work-specific decision goes on the card the work hangs off. One owner, the assignee. The decision is the first lines of the description, short, with the reason. Whoever picks the card up next, a person or an agent, reads that before they touch the code.
AGENTS.md is the rules. The board is the work. The way I keep a decision consistent across coding agents is to put it on the card the next session is pointed at.

The shape, at the top of the description. {name} is the assignee.
Decided: {the call}. Reason: {one line}. Do not reopen this.
{What to build.}
If that block needs a paragraph, it is not decided yet. What the agent should decide on its own, and what it should ask a named person, is in What coding agents should decide, and what they should ask you. Keeping that plan cheap to change, and reading it before an agent builds, is in A living project plan beats a perfect one.
What I do in Kahoona
I built Kahoona, so weigh this part.
The decision is text at the top of the card description. get_task returns that description. update_task replaces the description, so a session that rewrites the card has to keep the decided lines. Tell Claude Code, Cursor, or Codex to call get_task before it edits. How you connect them is in Let Claude Code and Codex pick up tickets from your board with MCP.
A comment is what a person reads in Activity. comment_on_task posts there. Kahoona's own agent is given the description and the last 20 comments when it starts. Each comment is cut at 1,000 characters, and the description is cut at 8,000, which is why the decision goes at the top and stays short. While the run is still queued, it reads the last 12 comments to decide whether the job is code or a reply. That text is handed over as untrusted card data. The prompt tells the agent not to follow directions written inside it, so a rules block is not a system instruction and it is not a gate. It is the spec on the card.
MCP has no tool that lists a task's comments. A Claude Code, Cursor, or Codex session that only calls get_task does not see a decision that lives only in a comment. Write it in the description.
You hand Kahoona's own agent the card by assigning it to Agent, or by writing @agent in a comment. Assigning it records you as the person who asked. A mention leaves the card with whoever already owns it. The mention does not take the card.
The run comes back as a GitHub pull request on the repo linked to the project. If the checks pass, or if none are configured, the pull request is marked ready, the card moves to In review, and it goes back to the person who assigned it. If the checks still fail after 2 fixes, the pull request stays a draft, the card says Needs you, and it goes back to that same person. The same hand-back happens when the run fails or gets stuck, as long as the card is still assigned to the agent and that person is still in the workspace. If they have left, the card is unassigned. A card someone already gave to another person is left alone.
A question during the run shows Question for you. The agent is told to ask, then carry on with its best assumption and say which one it made. A question does not pause the run.
Agents never merge and never deploy. There is no merge tool. The pull request says so. A person merges. A Claude Code, Cursor, or Codex session you start yourself is a different door. Kahoona does not attach to that terminal, and it will not stop the session from merging if GitHub lets it.
Kahoona does not copy the decision into AGENTS.md. It does not notice when two cards contradict. It does not message another agent's session. There is no check that catches the drift. Project memory can store a decision, and remember can write one, but memory writes are off until the project allows them. The default is off, and the agent is told to ask you before it records one. I keep the decision on the card, because that is what you point the next session at.
Intake is still mostly a person. create_task over MCP, and POST /api/projects/:projectId/tasks, can add the card. If you turn email-to-task on for the project, an email to that project's address becomes a new card. An email that names a card on that project, like WEB-14, and says done, completed, resolved, or fixed, moves that card to the complete column instead. Discord does not become a card. Slack does not. A client reply lands in the Client Inbox. Replying marks it handled. It does not become a card, and it does not change one. Someone on the team still makes the card for those.
The owner is the assignee. Stuck work comes back to that name. That is the longer version in Project manager accountability when you don't do the work. Several sessions on one board is in How to manage multiple Claude Code sessions without watching them.

When Kahoona is the wrong board
If the company already lives in Jira, stay there. Kahoona vs Jira. If the questions are already on Linear, stay there. Kahoona vs Linear. GitHub Projects is the right board when you want it inside GitHub and you do not want another product. Kahoona vs GitHub Projects. Trello is the right board when the work covers more than code. Kahoona vs Trello.
Kahoona is the wrong tool when you want it to catch a contradicting change, write the decision into AGENTS.md, or pull Discord and Slack into the backlog. It will not. It is also the wrong tool when you want the agent to merge.
Kahoona is free for one person. On a team the first chair stays free and each extra chair is $5 a month, so five people pay $20 and ten pay $45. It is a web app.
Keep the markdown file short. Put the decision on the card. One owner. The next session reads that before it edits.