Skip to the content
Krizaka Blog

10

A curve that climbs and climbs

Oct 9–25, 202610 min read

What I faced, An issue curve that never comes down; What we built, three projects, and a way to finish

A long wooden table in a brick workshop in Montréal, drawn in ink and pale watercolor: printed sheets, illustrated portraits, the mascots (an owl, a beaver, a flamingo), colour swatches, pencil wireframes, open notebooks, a mug and a laptop

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).

Issues of the krizaka organisation, running totals — data
DayOpenedStill openClosed, completedClosed, not planned
Sep 250000
Sep 260000
Sep 270000
Sep 280000
Sep 290000
Sep 300000
Oct 10000
Oct 20000
Oct 30000
Oct 40000
Oct 50000
Oct 6110110
Oct 7110110
Oct 8110110
Oct 94534110
Oct 108566190
Oct 11171142290
Oct 12215178370
Oct 13252199530
Oct 14278217610
Oct 154513588010
Oct 1653942310310
Oct 1779158813961
Oct 1880660214061
Oct 1982058417261
Oct 20937498227209
Oct 21998504260231
Oct 221,234628371232
Oct 231,468780448237
Oct 241,636876505252
Oct 251,687907525252
A few days of the curve (running totals)
DayOpenedStill openClosed, completedClosed, not planned
Oct 94534110
Oct 13252199530
Oct 1779158813961
Oct 20937498227209
Oct 221,234628371232
Oct 241,636876505252
Oct 251,687907525252

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
Why the curve climbs: opening work costs a minute, closing it takes a person who reads, checks and decides.

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.

A graphic collage of slate and indigo ink, with the Seyès ruling of a school notebook, Québec lease clauses and audit stamps
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.

ColumnCards
Incubation88
Backlog625
Next145
In progress16
In review74
Done522
Total1,470

I count the columns with one command. No token in the text: the terminal's gh uses the session that is already open.

bash
gh project item-list 4 --owner krizaka --limit 3000 --format json \
  | jq -r '.items[].status' | sort | uniq -c

In 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.

The board updates itself: GitHub Projects' built-in workflows move a card through its life, and a check every three hours catches the rest
  1. Added to the project (→ Backlog)An issue or a pull request joins the board.
  2. 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.
  3. Merged or closed (→ Done)The issue closes when its card becomes Done, old Done cards are archived, and sub-issues are added by themselves.
  4. Reopened (→ Next)A reopened item goes back to the work that comes next.
  5. 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.

Chapter 10

Results

public issues still open when the figures were read

907

The curve

issues closed as not planned on October 20

148

Cleaning up is not enough

repositories where the SonarCloud check is required on main

25

What changed in how we work