One evening, I opened the organisation's issues page on GitHub. There is a small chart at the top. I looked at it for a long time. The line of open issues kept climbing. The line of closed issues climbed too, but much more slowly.
This chapter is about what that curve taught me, and the decision I made while looking at it.
The curve
I did not want to copy GitHub's chart. I wrote a small script that asks GitHub's search, day by day: how many public issues were opened, how many were closed because the work was done, how many were closed as not planned. The script keeps the figures in a file, with the time they were read. Anyone can run it again.
Issues of the krizaka organisation, running totals
Public issues, per UTC day, counted by GitHub's search on October 25, 2026 at 1:34 a.m. (Montréal time). Open = opened minus closed.
Line chart, 4 × 31 (Sep 25 – Oct 25). Opened: from 0 to 1,687, lowest 0 (Sep 25), highest 1,687 (Oct 25). Still open: from 0 to 907, lowest 0 (Sep 25), highest 907 (Oct 25). Closed, completed: from 0 to 525, lowest 0 (Sep 25), highest 525 (Oct 25). Closed, not planned: from 0 to 252, lowest 0 (Sep 25), highest 252 (Oct 24).
| Day | Opened | Still open | Closed, completed | Closed, not planned |
|---|---|---|---|---|
| Sep 25 | 0 | 0 | 0 | 0 |
| Sep 26 | 0 | 0 | 0 | 0 |
| Sep 27 | 0 | 0 | 0 | 0 |
| Sep 28 | 0 | 0 | 0 | 0 |
| Sep 29 | 0 | 0 | 0 | 0 |
| Sep 30 | 0 | 0 | 0 | 0 |
| Oct 1 | 0 | 0 | 0 | 0 |
| Oct 2 | 0 | 0 | 0 | 0 |
| Oct 3 | 0 | 0 | 0 | 0 |
| Oct 4 | 0 | 0 | 0 | 0 |
| Oct 5 | 0 | 0 | 0 | 0 |
| Oct 6 | 11 | 0 | 11 | 0 |
| Oct 7 | 11 | 0 | 11 | 0 |
| Oct 8 | 11 | 0 | 11 | 0 |
| Oct 9 | 45 | 34 | 11 | 0 |
| Oct 10 | 85 | 66 | 19 | 0 |
| Oct 11 | 171 | 142 | 29 | 0 |
| Oct 12 | 215 | 178 | 37 | 0 |
| Oct 13 | 252 | 199 | 53 | 0 |
| Oct 14 | 278 | 217 | 61 | 0 |
| Oct 15 | 451 | 358 | 80 | 10 |
| Oct 16 | 539 | 423 | 103 | 10 |
| Oct 17 | 791 | 588 | 139 | 61 |
| Oct 18 | 806 | 602 | 140 | 61 |
| Oct 19 | 820 | 584 | 172 | 61 |
| Oct 20 | 937 | 498 | 227 | 209 |
| Oct 21 | 998 | 504 | 260 | 231 |
| Oct 22 | 1,234 | 628 | 371 | 232 |
| Oct 23 | 1,468 | 780 | 448 | 237 |
| Oct 24 | 1,636 | 876 | 505 | 252 |
| Oct 25 | 1,687 | 907 | 525 | 252 |
| Day | Opened | Still open | Closed, completed | Closed, not planned |
|---|---|---|---|---|
| Oct 9 | 45 | 34 | 11 | 0 |
| Oct 13 | 252 | 199 | 53 | 0 |
| Oct 17 | 791 | 588 | 139 | 61 |
| Oct 20 | 937 | 498 | 227 | 209 |
| Oct 22 | 1,234 | 628 | 371 | 232 |
| Oct 24 | 1,636 | 876 | 505 | 252 |
| Oct 25 | 1,687 | 907 | 525 | 252 |
On October 9, there were 34 open issues. When the figures were read, on October 25 at 1:34 in the morning, 1,687 issues had been opened since the start. 525 were closed as done, 252 closed as not planned, and 907 were still open.
October 25 is not a full day: the curve stops at the time of the reading. The days are GitHub's, in UTC. The script and its figures are in the blog's repository: scripts/gen-issue-curve.mjs and lib/issue-curve.json.
Opening costs almost nothing
With agents, an idea becomes an issue in a minute. I describe what I want, the agent writes the issue, with the context, the criteria, the links. An issue becomes a pull request almost as fast. Sometimes an agent working on one issue opens three more, because it saw a problem next door. It is right to write it down. But every note goes on the pile.
The big days of the curve show it. On October 17, 252 issues were opened. On the 22nd, 236. On the 23rd, 234. On those days we were writing plans: epics, slices of work, ideas parked for later. Writing a plan is useful. But a plan written as issues is one promise per line.
Closing is the real work
Closing an issue takes what an agent does not do alone. Someone has to read the code, check that the CI really ran, that the test proves what it says, that the PR breaks nothing elsewhere. And someone has to decide. That is me.
Review became the place where everything waited. On October 25, krizaka-ui had 25 open pull requests, most of them never reviewed. We sorted them that day, one by one: merge, fix, or close with an explanation.
And every day there was the same puzzle. Do I move a new feature forward, or do I bring the number of open issues down? Both feel urgent. A feature shows. A closed issue barely shows. But an open issue weighs.
Opening
- An idea becomes an issue in a minute
- The agent writes the context, the criteria, the links
- An issue becomes a PR almost as fast
- An agent on one issue may open three more
- 252 issues opened on 17 October
Closing
- Someone reads the code
- Checks that the CI really ran
- That the test proves what it says
- That the PR breaks nothing elsewhere
- And decides: me
Cleaning up is not enough
On October 20, I cleaned up. 148 issues were closed as not planned that day. There were checklists a script had created twice, work already done, work replaced by another issue. And there were ambitious ideas, features nobody seemed to have asked for. The line of open issues came down, from 584 to 498.
Except that some of those ideas were mine. I had launched them through my agents one evening, without telling the agent doing the triage. For it, they came from nowhere. It closed them.
I don't want to lose an idea because it is not a priority today. So we changed the rule. We now close only three things: a duplicate, work already done or replaced, and work that is wrong or harmful. Every other idea goes to a new column of the board, Incubation. An idea in Incubation is kept and visible. It is not a priority: nobody works on it until I move it forward. And when in doubt, it goes to Incubation.
We went back over the issues closed as not planned in October, one by one. 88 came back into Incubation. The others stay closed, with a link to the original or to what replaces them. The curve above is the one read at 1:34 in the morning: it still counts those 88 ideas among the closed issues.
Two days later it was higher than before: 628 open issues at the end of October 22.
That is when I understood. The problem was not the number of issues. It was the number of projects. When you work on everything at once, every project opens work, and nobody closes it.
Three projects
So I chose. We focus on three things.
Orazaka, the engine. It runs the AI of the products. Without it, nothing works.
Yomizaka, first. It verifies documents and prepares a tenant's file, for businesses. It is a real need: checking a file today takes time and lets mistakes through.
Akinaza, right after. It handles appointments, invoices and the preparation of taxes for service businesses in Québec. Here too, it is a need I see around me: people who are good at their trade and lose their evenings to paperwork.
How this was made
- Model
- not recorded
- Engine
- not recorded
- Machine
- hosted by the provider (not our machine)
- Time
- not recorded
- Cost
- not recorded
- Sovkora run
- not recorded
- Note
- Banner 05 of the Krizaka default media kit (Oussama's set of avatars and banners), made outside Orazaka: its model, prompt and time were not recorded.
These two products are our flagships. The goal is for them to find their market: people using them because they need them, not because we showed them a demo.
The rest waits. The other ideas are not abandoned, but we open no new work there until the first three move forward.
What changed in how we work
Choosing three projects is not enough if we keep working the same way. Here is what is in place today.
Where does a task start?
- Before
- From an idea, a conversation, an agent.
- Now
- From an issue. With a priority, on one board for the whole organisation.
When is a PR ready?
- Before
- When it looks finished.
- Now
- When the CI is green and SonarCloud passes. The SonarCloud check is required on main in 25 repositories.
Who fixes a small review comment?
- Before
- The agent, the PR goes back to it.
- Now
- The reviewer. They make the small fix themselves. Only a large change goes back to the author.
What happens to a bug found in review?
- Before
- We fix it.
- Now
- We fix it, and if it is a class of bugs, we write a rule. The rule refuses the pattern everywhere, the next time.
How many working sessions at once?
- Before
- As many as possible.
- Now
- Three at most.
Issue first sounds like bureaucracy. In practice, it is what lets me follow. An issue says why we do the thing, a PR says how, and the board says where we are. When a session stops in the middle, the next one knows where to pick up.
A rule after a bug is a habit I picked up while reviewing. In Yomizaka, a date was computed in UTC instead of Québec's day. We fixed it, then wrote a rule that refuses the pattern. I tell it in the chapter on the audit. A fixed bug is one bug less. A rule is one class of bugs less.
Three sessions at most is the lesson of the day we wanted to finish everything. More sessions is not more finished work. It is more open work.
How I follow the work
I don't code every line. I don't even read every issue. What I look at is the organisation's board: one board for every repository, with six columns.
- Incubation: an idea kept and visible, not a priority yet.
- Backlog: work accepted, not planned yet.
- Next: what comes next.
- In progress: what is being done right now.
- In review: a pull request exists, it waits for CI or a review.
- Done: finished.
It is my 360° view. I see what moves from one column to the next, what gets stuck, what grows. When a column goes the wrong way, I say so, and we change direction. I decide where we go. The agents and the automations move the cards.
Here is the board on October 25 at 3:55 pm, Montréal time, just after the ideas came back into Incubation.
| Column | Cards |
|---|---|
| Incubation | 88 |
| Backlog | 625 |
| Next | 145 |
| In progress | 16 |
| In review | 74 |
| Done | 522 |
| Total | 1,470 |
I count the columns with one command. No token in the text: the terminal's gh uses the session that is already open.
gh project item-list 4 --owner krizaka --limit 3000 --format json \
| jq -r '.items[].status' | sort | uniq -cIn progress is small, on purpose: three sessions at most. In review is high. That is not 74 reviews waiting for me. A card moves to In review as soon as a pull request is open. Many wait for CI to finish, and auto-merge is armed: the PR merges by itself once everything is green. At that moment, 39 pull requests were still open, down from 104 when the curve was read in the night, and 24 had auto-merge armed. The others wait for a fix or for my decision.
Backlog, finally, is the real pile. That is the one that has to come down.
The board updates itself
I swept the board. 45 cards were still in In progress or In review although their issue or PR was already closed or merged. 25 others sat in In review with no activity since October 20 or 23. The cause is simple: a session moves the card to In review, and nobody moves it again after the merge. I fixed all 70: the closed ones to Done, the sleeping ones back to Next.
I did not want to do that sweep by hand again. So I turned on GitHub Projects' built-in workflows, in the board's settings. Before that, several were broken: they pointed to a “Todo” column that no longer existed.
- Added to the project (→ Backlog)An issue or a pull request joins the board.
- A pull request linked (→ In review)The PR is linked to its issue. Changes requested send the card back to In progress; an approved review returns it to In review.
- Merged or closed (→ Done)The issue closes when its card becomes Done, old Done cards are archived, and sub-issues are added by themselves.
- Reopened (→ Next)A reopened item goes back to the work that comes next.
- Every three hours (the safety net)A plan check finds the cards whose column does not match their issue or PR, and fixes them.
It is the same principle as for CI: automate the check instead of doing it by hand.
What is not solved
I do not want to end on a victory. There is none yet.
The number of open issues is still high. When the figures were read, there were 907 open issues and 104 open pull requests in the organisation. The curve has not turned yet. What I am waiting for now is the line of done issues climbing faster than the line of opened ones. I will run the script again to check, and publish the result, good or not.
SonarCloud is not a magic fix either. We use the free plan, and it has limits: we keep the default quality gate, which mostly judges new code. The problems already there block nothing as long as nobody touches them. The check stops the pile from growing. It does not bring it down.
And review still rests on one person. The rules and the CI say no early, but they do not choose what matters.
What I take from it
With agents, speed is no longer the problem. Finishing is. Every open project, every issue, every PR waits for something from me: a review, a decision, a little attention.
So I do fewer things at once. One engine, two products that answer a real need, and one simple rule: we finish before we start.
