How the industry tracks AI coding work across many projects
I work on several side projects at once, and an AI agent writes most of the code in all of them. That makes each session fast, and it makes one problem bigger: when I come back to a project after four days, where was I, and what is next? The agent's chat is gone, the plan in my head is gone, and the idea I had halfway through the last session ("this screen also needs an empty state") is only gone if I didn't write it down.
My answer is boring on purpose: GitHub Issues and one GitHub Project board. Every feature, bug or idea becomes an issue the moment it appears, every issue lands on the board automatically, and merges move its status, so I start any project by opening its board view, not by remembering. It plugs into what I already use, Claude Code and GitHub, with no new app to check.
I wanted to know whether that is how the industry solves it, or whether I am the only person still filing issues while agents write the code. So this post looks at the research on why resuming work is expensive, the three places teams now keep "where was I", and how my setup compares.
TL;DR
- Resuming is the expensive part, and the research is clear about it. Programmers rarely start editing again within a minute of coming back to an interrupted task. Most first navigate around the code to rebuild context, and in about 30% of sessions the first edit comes more than 30 minutes later. Writing down where you are and what comes next before you stop measurably reduces the cost.
- AI agents make it worse, not better. The agent forgets between sessions, and running several agents at once means more half-finished work in flight. METR now says its time measurements are unreliable for developers who use multiple agents, because they switch to other work while an agent runs.
- The industry keeps "where was I" in three places: the session (Claude Code's resume and memory files), the repository (progress files, specs, task files such as Beads or Backlog.md), and the tracker (GitHub Issues, Linear, Jira), where agents are now assignees that pick up an issue and come back with a pull request.
- They answer different questions. The session remembers the conversation, the repo remembers one project's plan, and only the tracker shows every project and every captured idea in one place without opening anything.
- My setup is the tracker layer plus a little of the repo layer, and the industry has moved toward it: GitHub, Linear and Atlassian all now treat "assign the issue" as the way to hand work to an agent. The two things I am taking from the others are a written ready-to-resume note when a session stops, and a progress file for long agent runs.
Why "where was I?" costs so much
The cost of switching tasks is one of the most-quoted numbers in software, and usually misquoted. "It takes 23 minutes to refocus after an interruption" is attributed to Gloria Mark, a professor at UC Irvine. The figure comes from a 2006 Gallup interview, in which she said that interrupted work resumed the same day "was resumed, on average, in 23 minutes and 15 seconds", and that "there are about two intervening tasks before you go back to your original task." Her peer-reviewed study of 24 information workers, "No Task Left Behind?" (CHI 2005), reports 25 minutes 26 seconds, with a standard deviation of almost 55 minutes. Both numbers measure time until people came back to a task, after doing other things, not time to regain focus. Her later lab study, "The Cost of Interrupted Work" (CHI 2008), found something different again: interrupted people worked faster to compensate, "but this comes at a price: experiencing more stress, higher frustration, time pressure and effort."
The numbers that matter more for programmers come from Chris Parnin and Spencer Rugaber, who analysed 10,000 recorded programming sessions from 86 programmers and surveyed 414 more, in "Resumption strategies for interrupted programming tasks" (Software Quality Journal, 2011):
- "only 10% of the sessions have programming activity resume in less than 1 min after an interruption", and in only 7% did the programmer start editing without first navigating to other places in the code.
- "In about 30% of sessions, the edit lag is over 30 min."
- Programmers rebuild their context by reading code, running the program, looking at the diff, searching for TODOs, and even leaving a deliberate compile error as a roadblock to find later. And "77% of participants responded that they actively track the status of tasks with note-taking", in the bug tracker, in notes, in the code or on paper.
Two more findings explain why writing it down is the fix rather than a nice habit:
- The unfinished task keeps running in your head. Sophie Leroy (2009) called it attention residue: people who leave a task unfinished keep thinking about it and do worse on the next one. In a later study with Theresa Glomb, "Tasks Interrupted" (2018), a short ready-to-resume plan, written before switching, reduced that residue and prevented the drop in performance.
- A plan is enough to let go. E. J. Masicampo and Roy Baumeister showed in "Consider It Done!" (2011) that unfinished goals cause intrusive thoughts and hurt unrelated work, and that "allowing participants to formulate specific plans for their unfulfilled goals eliminated the various activation and interference effects", even though the goal was still unmet. It is the research behind David Allen's Getting Things Done slogan: "Your mind is for having ideas, not holding them."
What AI agents change
An agent does not remove the problem; it moves it. Each Claude Code session starts with a fresh context window, as its memory docs put it, so the agent has to be told where things stand every time. And because agents work while you wait, you switch more. METR's randomized trial of experienced open-source developers in early 2025 found them 19% slower with AI tools while they believed they were faster. Its February 2026 update calls that result outdated, and adds the detail that matters here: "our measurements of time-spent on each task are unreliable for the fraction of developers who use multiple AI agents", because developers "would often work an unrelated task while waiting for the agent to complete its work."
More projects, more agents and more parallel work mean more unfinished tasks in flight. Something outside your head, and outside any one chat, has to hold them.
Three places to keep "where was I"
1. The session: resume the conversation
The cheapest layer is the agent's own memory, and Claude Code has a lot of it now (sessions docs):
claude --continuereopens the last session in a directory,claude --resumeopens a picker, andclaude --from-pr <n>finds the session linked to a pull request.- Sessions can be named: the best-practices guide suggests that "for work that spans several days,
/rename oauth-migrationin the session names it, so thatclaude --resume oauth-migrationfrom your shell picks it back up later, checkpoints included." CLAUDE.mdholds the rules you write, and auto memory holds what Claude learns on its own, loaded at the start of every session. AGENTS.md is the cross-tool version: "a README for agents", now stewarded by the Agentic AI Foundation under the Linux Foundation.- Claude can keep a task checklist during multi-step work, and
CLAUDE_CODE_TASK_LIST_IDshares one list across sessions.
This layer is excellent for the next morning on the same project. It is weak for my case: transcripts are kept 30 days by default and live on one machine, memory files hold rules and lessons rather than a backlog, and nothing in a session tells me which of eight projects to open.
2. The repository: the plan travels with the code
The second layer writes the state of the work into files in the repo, where any session, any agent and any person finds them.
- Progress files. Anthropic's engineering post "Effective harnesses for long-running agents" (Justin Young, November 2025) has a first agent set up
init.sh, "a claude-progress.txt file that keeps a log of what agents have done", and a JSON feature list where every feature starts as failing. Every later session gets its bearings the same way: "Read the git logs and progress files to get up to speed on what was recently worked on," then "choose the highest-priority feature that's not yet done to work on." They chose JSON over Markdown because the model is less likely to rewrite it carelessly. - Specs with task lists. GitHub's Spec Kit, announced by Den Delimarsky in September 2025, goes from spec to plan to
tasks.md, underspecs/<feature>/, treating specs as "living, executable artifacts that evolve with the project". Kiro specs do the same withrequirements.md,design.mdandtasks.md, where "tasks are updated as in-progress or completed, allowing you to efficiently track implementation progress." - Memory banks. Cline's Memory Bank is a folder of Markdown files, including
activeContext.md(current focus and next steps) andprogress.md(what works, what is left), with a rule that says "I MUST read ALL memory bank files at the start of EVERY task." - Issue trackers in the repo. Backlog.md keeps "every task" as "a plain
.mdfile in your repo", with a CLI, a terminal Kanban board and an MCP server. Task Master turns a PRD into tasks with dependencies, picks the next one withtask-master nextand adds new ones withadd-task. Steve Yegge's Beads is a dependency-aware issue graph built for agents, which "provides a persistent, structured memory for coding agents": an agent asksbd readyfor work with no open blockers, claims it, and runsbd primeat the start of a session to load its context.
The repo layer is the strongest answer to "what does the agent do next in this project". Its limit is the one in its name: it lives in one repository. To see what is pending across eight projects, I would have to open eight repos.
3. The tracker: issues that agents can take
The third layer is the oldest one, the issue tracker, and it is where the big platforms put their agents in 2025 and 2026. The pattern is the same everywhere: the issue is the unit of work, assigning it is how you hand it to an agent, and the result comes back as a pull request.
- GitHub. You can assign an issue to Copilot like a teammate, and "assigning an issue always creates a pull request." Sessions are tracked in mission control, which became an Agents tab in each repository in January 2026, "alongside your code, pull requests, and issues." GitHub Projects shows the same issues as a table, a board or a roadmap, and its built-in workflows set an item to Done when it closes or its PR merges.
- Linear. Linear for Agents (May 2025) made agents "first-class users in Linear". You delegate an issue by assigning it; the agent becomes the delegate while a person stays the assignee. Cursor, OpenAI's Codex and Devin all take Linear issues this way (Cursor: "Assign any issue to
@Cursor"). - Jira. Atlassian's Remote MCP server launched with Anthropic as its first partner and is now generally available as the Rovo MCP Server. Its Jira coding agent takes an assigned work item to a draft PR, and "won't merge the draft pull request directly, but will hand it back to your team for review and merge."
- From Claude Code, the other way round. The tracker does not have to start the agent. The GitHub MCP server and Linear's MCP server let a Claude Code session read the backlog and file new issues mid-session, and Claude Code GitHub Actions lets you write
@claudein an issue "to turn issues into pull requests".
The tracker is the only layer that answers both of my questions at once: what is pending across all my projects, and where do I put an idea so it is not lost. It is also the only one I can check from my phone without cloning anything.
The three layers side by side
| Question | Session (Claude Code resume, memory) | Repository (progress files, specs, Beads, Backlog.md) | Tracker (GitHub Issues + Projects, Linear, Jira) |
|---|---|---|---|
| What did the agent just do? | Best: the full transcript | Good: progress log, git history | Only what the PR and issue say |
| What is next in this project? | Weak | Best: ordered tasks, dependencies | Good: board order, labels |
| What is next across all projects? | No | No, one repo at a time | Yes: one board, a view per repo |
| Where does a new idea go mid-session? | Lost unless filed | A new task file, in that repo | A new issue, from anywhere |
| Lasts how long? | 30 days by default, one machine | As long as the repo | As long as the account |
| Who else can see it? | Nobody | Anyone with the repo | Anyone you share the board with |
| Hands work to an agent? | It is the agent | The agent reads it | Assign the issue |
The layers work best together, and that is roughly where the industry has landed: a tracker for what and what next, files in the repo for the plan of the feature in progress, and the session for the work itself.
My setup: the board remembers
Everything lives in one GitHub Project, AI Coding Planner, with a roadmap view for all projects and a saved view per repository (repo:<owner>/<repo>). Today it holds 251 issues from 8 repositories: 195 Done, 9 In Progress and 47 Todo. The rules are in projects-workflow-ai, the repo every project is bootstrapped from, and the whole pipeline is on how I ship software.
Capture. When an idea or a missing feature turns up, it becomes an issue straight away, usually without leaving the session. /problem-to-issues turns a problem description into reviewed issues and creates them with gh after I approve them; for a single idea, gh issue create is enough. A workflow, add-issue-to-project, adds every new issue to the board on GitHub's side, so it lands there however it was created: from Claude Code, the CLI, the web or my phone.
Resume. Coming back to a project after days means opening its board view, not my memory. In Progress is what I was doing; the top of Todo is what is next. The session then starts from the issue: /spec-from-issue 42 writes or amends the feature's spec, and a fresh session runs /implement-tasks on it. The agent never needs me to retell the story, because the issue, the spec and the task list are its context. The same steps can also run unattended, as Kiro Workflows recipes that stop at an open pull request.
Status nobody has to remember to update. A second workflow runs on every merge into staging that touches a spec. It reads each issue's section of tasks.md before and after the push: new tasks move the issue to In Progress, all boxes checked moves it to Done and closes it. The board reflects what has been merged, not what I said I would do.
One lesson in the plumbing. The status workflow once found an issue's board item by listing the project's items. In August 2026 the project passed 100 items, the query only returned the first page, and every newer issue came back "not found in project": the runs were green and no status was ever written. It now looks the item up from the issue's side. A board that silently stops updating is worse than no board, so the fix came with a test that simulates the page limit. (The token those workflows use has its own story: the GitHub token my public repo should never have held.)
One exception. My game project, World Rift Conflict, deliberately runs on AWS AI-DLC instead, which keeps its own state file and audit trail per piece of work, the repository layer in its purest form. How it remembers across sessions is in part 14, memory layers.
How mine compares, and what I am borrowing
My setup is the tracker layer on GitHub, with the repo layer (Kiro-style specs and tasks.md) for the feature in progress, and the session layer only for the session itself. Measured against the rest:
- Where it matches the industry. The issue is the unit of work, an agent starts from the issue, the result is a pull request, and a person merges. GitHub, Linear and Atlassian all ship that pattern now, and my comparison of Anthropic's AI SDLC, AWS AI-DLC and Cursor's pstack found the same idea in their artifacts: the chain of files in git is the memory.
- Where it does more than the defaults. GitHub's built-in automation only knows closed, merged and added. Mine also knows started, because it reads the spec's tasks, and it handles a later issue that amends an existing feature.
- Where it is thinner. An issue says what; it does not say where I stopped. Leroy and Glomb's ready-to-resume plan is exactly the missing piece, so it is the next change to my skills: a session that stops mid-issue leaves a short comment on the issue saying what is done, what is next and what to check first. Parnin and Rugaber's programmers did the same thing with TODOs and deliberate compile errors.
- What I would add for long agent runs. For work that spans many sessions inside one feature, Anthropic's progress file and failing-first feature list are cheap and proven, and they live next to
tasks.mdwithout replacing it. - What I am not adopting yet. Assigning issues to Copilot, or Linear and Beads as a second tracker. The value of one board is that it is one board; a second place to look brings back the problem it solves.
Which one should you use?
- One project, a few days at a time: the session layer is enough. Name long sessions and resume them; keep rules in
CLAUDE.mdorAGENTS.md. - One project, long agent runs: add the repository layer: a progress file and a task list the agent reads first (Anthropic's harness, Spec Kit, Kiro specs, Backlog.md or Beads).
- Several projects, or ideas that arrive anywhere: add a tracker, and make capture one command and status automatic. If you already live on GitHub, Issues plus one Project with a view per repo costs nothing extra and works with Claude Code through
ghand the GitHub MCP server. If your team lives in Linear or Jira, both now take agents as assignees.
Whatever you pick, the research says the same two things: write the next step down before you stop, and keep it somewhere you will look first. For me that is the board.