A living project plan beats a perfect one

A living project plan is only useful while it is still true. Keep it rough on the board, review the card before an AI agent builds, and let GitHub move the status.

A living project plan is the one that is still true. A detailed plan that takes an afternoon to update stops being the plan. How cheap it is to change matters more than how accurate it was on day one. A project plan with AI agents has two extra holes. More work lands every week, and the agent will write the plan too if nobody reads it first.

The detailed plan became a whiteboard

The most detailed plan I ever built was also the most useless one

Years ago I spent nearly three weeks building a plan for a large program. Every task estimated, every dependency mapped, people allocated down to half-days. Leadership loved it.

Three weeks into delivery, reality drifted. A supplier ran late, a client review moved, two people got pulled elsewhere. Normal stuff. But updating that plan properly took most of an afternoon each time, so I started batching changes weekly, then every other week. By month two the real plan lived on a whiteboard, and the beautiful one was basically a historical document.

A few years later I ran something similar with a much rougher plan that took a couple of minutes to change. It was less impressive and probably less accurate on day one, but people actually used it, because it was still true.

That contrast made me wonder whether a good plan is less about how accurate it is at the start and more about how cheap it is to change. Though I can see where that breaks down, in construction or regulated work the detail is often the point, and maybe my first plan failed because of the tool, not the detail.

How do you see it? Have you had a detailed plan die because keeping it current was too painful?

Reddit

Little_Classic6023 u/Little_Classic6023 r/projectmanagement

· Score 5 · 6 comments

as of

u/Little_Classic6023 posted that on November 17. The plan took nearly three weeks to build.

Every task estimated, every dependency mapped, people allocated down to half-days. Leadership loved it.

But updating that plan properly took most of an afternoon each time, so I started batching changes weekly, then every other week. By month two the real plan lived on a whiteboard, and the beautiful one was basically a historical document.

A few years later I ran something similar with a much rougher plan that took a couple of minutes to change. It was less impressive and probably less accurate on day one, but people actually used it, because it was still true.

That contrast made me wonder whether a good plan is less about how accurate it is at the start and more about how cheap it is to change.

Yup. The first one looked better. People used the second one. The problem aint the detail on day one. It is the afternoon it costs to change it. Leadership liking the spreadsheet does not make that spreadsheet the plan the team is on.

The fair counterpoint is in the same post. "in construction or regulated work the detail is often the point". Yup. If the drawing is the contract, the detail is the work. I am talking about a software board, where you already expect the plan to be wrong by Thursday.

u/IHZ66 wrote:

Do you really need people down to half days?

No. Half-days are why the update took an afternoon. A card with one owner is enough. I do not schedule people in half-day blocks, and Kahoona does not either.

u/New_Biscotti9915 uses Claude to keep a schedule current:

It adds tasks, marks them complete plus when they were completed, maintains all the dependencies and gives me updates when we drift

That is a different job. Kahoona does not maintain a dependency schedule, and it does not tell you when a plan drifts. You can mark one card blocked by another card in the same project. The standup lists the blocked card as stuck until that blocker is in Done. A due date can sit on the card. The timeline view shows due dates for the next four weeks, a bar on the date. It does not draw dependencies.

The software template has an Estimate field, in points, and a Sprint field that is a text label. Every template has an Effort field, XS through XL. Those are labels you type. Nothing reads them and replans the board. If you want a schedule that updates itself, this is the wrong tool for that part.

A living project plan has to change with the week

On r/agile, We don't plan anything and it drives me nuts by u/EarlOfAwesom3, posted November 17:

We supposedly have a weekly planning, but the PM just brings up the same high level roadmap that never changes.

Then we go on with whatever is thrown at us in the week: high prio bugs, urgent customer request, some vibe coded PRs or random tickets (with AI generated).

u/EarlOfAwesom3 wrote:

We do have a board but we only use it to track tickets in swim lanes.

u/ShaneKuchelExecCoach wrote:

AI increases the volume of work coming at the team. More PRs, more tickets, faster. That makes deciding what not to do more important, not less.

Yup. A roadmap that never changes, plus vibe coded PRs and random tickets, is a slide. A board that only holds swim lanes is the same slide with columns. The volume went up. Deciding what not to do is the planning. I want that call on a card someone owns, and I want the card to move the week the pull request opens. Quarterly is already too late.

Dropping the two-week planning meeting, for a small team whose cards come back in hours, is a separate argument. That writeup is Sprint planning for small teams when agents ship in hours. This one is about keeping a project plan up to date because changing it is cheap.

Read the card before the agent builds

Everyone’s excited about spec driven dev/ factories but every company we talk to we keep seeing - claude writes the design doc, nobody really reviews it, claude builds it

claude still makes bad design calls. reviewing PRs for errors hardly matters when the entire design is off to begin with

X

Aiswarya Sankar @aiswarya_sankar

· 40 likes · 2 reposts · 12 replies

as of

Aiswarya Sankar posted that on November 16.

Everyone’s excited about spec driven dev/ factories but every company we talk to we keep seeing - claude writes the design doc, nobody really reviews it, claude builds it

claude still makes bad design calls. reviewing PRs for errors hardly matters when the entire design is off to begin with

Yup. If Claude wrote the design doc and nobody read it, the pull request review is looking for typos in the wrong document. The design was already off. The cheap human checkpoint is the card, before you assign it. PR review stays. A person still merges. It is late for the plan.

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. The decision at the top of the description, so the next session sees it, is in A markdown backlog for AI coding agents. A one-line status, when a line is not enough, is in A status update template for agents: BLUF, then SBAR. I am not repeating those.

The plan I keep is the card. One owner. A few lines in the description.

Plan: {what done looks like}.
Out: {what this card will not do}.

If that needs a page, it is not decided yet. You read those lines, then you assign the card to Agent, or you write @agent in a comment. The run comes back as a GitHub pull request. Agents never merge.

Two columns. A detailed plan takes an afternoon to update, gets batched, and by month two the real plan is on a whiteboard. A rough plan is cards on the board: one owner, a pull request opens and the card moves, a merge with a closing word moves it to Done.
Diagram. Cheap to change beats detailed on day one. Kahoona does not map a dependency schedule, and it does not review the plan for you.

What I do in Kahoona

I built Kahoona, so weigh this part.

The plan is the card description. get_task returns that description. 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 at 8,000, which is why the plan 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. The plan is the spec on the card. It is not a gate.

MCP has no tool that lists a task's comments. A Claude Code, Cursor, or Codex CLI session that only calls get_task does not see a plan that lives only in a comment. Write it in the description. The install list also has Claude Desktop and VS Code. How you connect them is in Let Claude Code and Codex pick up tickets from your board with MCP.

You hand Kahoona's 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. One project runs one of those agents at a time. The next card waits.

If you assigned the card and the description is under 60 characters, the queued card says "Add what done looks like. The agent does much better with a clear spec." That is a length nudge. It is not a review of the plan. Nobody in the app reads the plan for you. A question during the run shows Question for you, and the agent is told to keep going on its best assumption. A question does not pause the run. That is also not the plan review.

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. The comment says the pull request is ready for review and names the link. The pull request body includes Fixes and the card key, such as Fixes WEB-14. If the checks still fail after 2 fixes, the pull request stays a draft, the card says Needs you, it sits in In progress, 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 mention does not hand the card back.

GitHub moves other cards on its own, when a pull request references the card and the sender is not a bot. A draft opening moves the card to In progress. A non-draft open, or a draft marked ready for review, moves it to In review. A merge into the branch the project watches moves it to Done, and only when the title or body uses a closing word right before the card. Close, closes, closed, fix, fixes, fixed, resolve, resolves, resolved, complete, completes, completed. A mention, or the branch name alone, links the card and does not complete it. A bot sender is ignored, which is why the agent's own open does not depend on that webhook. A person's merge does. The card does not walk backwards on its own. Closing a pull request without merging only suggests a move back. A newer change by a person or the agent beats the GitHub event. A failed GitHub check does not move the card. The standup can list that open pull request as stuck.

The standup is computed from the board. The line on the page is "Written from your repo and board." It groups by the person who owns the card. Since yesterday is the previous working day, so Monday and the weekend look back to Friday. This week starts on Monday, in your timezone. Shipped is cards in Done in that window. A linked pull request that updated to merged in the window can mark the time. On it is a card in a working column, In progress or In review on the default board. Stuck is an unfinished blocker, failing checks on an open or draft pull request from the last week, or a client approval that is still pending or has changes requested. It does not ping anyone. The agent user is not a member, so a card still assigned to Agent does not get a standup column. When the run finishes, the card is back on the person who asked, and that is the name on the wall.

A short paragraph sits above that wall. It is written when you open the standup, if none is cached or the cached one is older than an hour. With an LLM gateway it asks for two or three sentences, stuck first. Without one, or if the model errors, it is a plain line from those same counts. The shared paragraph only includes workspace-visible projects. There is a Copy as update button. You are not writing the status in a separate doc. Reading that list before anyone talks, and meeting only on what is stuck, is in Replace the daily standup with what shipped.

The Friday update is the weekly timeline on the GitHub tab. Weeks start Monday, UTC. Each pull request and each issue is its own theme. Loose commits, checks, and notes sit in those three buckets. The counts are already there, from the repo. The paragraph is written the first time you expand that week, from the GitHub activity already on the page. Over MCP, weekly_digest returns those counts and themes. That call does not write a new paragraph.

Who merges, named before the run starts, is in Name a human owner before the agents open pull requests. One owner, and stuck work coming back to that name, is in Project manager accountability when you don't do the work.

A sample Kahoona card, Refund window, in review. The description is a short plan, checkout copy stays at 14 days, and the run came back as pull request 241 ready, handed back to Aisha.
Sample card. You read the plan in the description, then assign the card. A finished run shows the pull request as ready and hands the card back. Kahoona does not review the plan. A person merges.

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 a dependency-mapped schedule, people allocated to half-days, something that replans itself, or an agent that reviews the plan for you. It will not. It is also the wrong tool when the detail is the contract, which is the construction and regulated case above. And it is 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 plan short enough that changing it is cheap. Read it before the agent builds. Let the board move with the pull requests.

Questions

What is a living project plan?

A plan people still use because it is still true. On a software board that is cards with one owner and a short plan in the description, cheap enough to change the week the work changes. A detailed plan that takes an afternoon to update stops being the plan.

Where is the plan review before coding agents build?

On the card, before you assign it. Kahoona's agent is given the description and the last 20 comments, then it builds. Reviewing the pull request is late if the plan on the card was already wrong. Kahoona does not review the plan for you. A queued card with a description under 60 characters says to add what done looks like. That is a length nudge, not a review.

How do you keep a project plan up to date when AI agents add work every week?

Put the plan on the cards the work already moves on. A pull request that names the card moves it. A draft opening moves it to In progress. A ready pull request moves it to In review. A merge to the branch the project watches moves it to Done when the title or body uses a closing word, such as Fixes WEB-14. The standup and the Friday update are written from that board and from GitHub when you open them. Kahoona does not replan a dependency schedule.

What does Kahoona cost?

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.