Skip to main content
This page says what is coming and in which order. It carries no dates: what is written here is the order the work is taken in, and that is the only thing anyone can promise honestly about software written a task at a time. The order is not a ranking of how interesting the work is. It is what a mistake costs the person who meets it. Things that take work away from you come first, however small they are to fix. Things that tell you something untrue about the state of your project come next, because you cannot act on a report you cannot trust. Things that merely cost time come after those. New capabilities come last, and wait for all of it. Known issues describes the faults themselves — what you see, what it costs, and what to do instead until each one is fixed.

First: what takes work away from you

Nothing known today. When something is found, it goes here, ahead of everything below.

Then: what tells you something untrue

A green verify must belong to the files it checked. A review already records what it read, and says so when the code moves on underneath it. A verify result does not: once the checks pass, the task reads as verified even if files changed afterwards, and a change can be shipped under a result that was earned by a different tree. The result gets pinned to its inputs, the way the review is, and a moved tree asks for a new run. A write from a page must only ever publish what it was meant to. 0.40.0 made a roadmap edit and a knowledge decision possible without moving your checkout, and a rule stops a write publishing commits origin never had. The faults found since, around pull requests closed or squashed under it and branches deleted on origin, are fixed in 0.41.0. Next, a smaller step: a spec created after a write already took its branch name should get another name. jig spec new now refuses it when that branch is in your clone, and loses nothing; a write branch that exists only on origin is not caught yet. From 0.45.0 jig refresh closes a write whose pull request merged — squashed included — or closed.

Then: what costs you time

A second review round must not open a new front. A repeat review already reads only what changed since the review (0.30.0). What is left: a blocker that appears only in the second round goes to you instead of starting a third. Each extra round is where the time goes, and this bounds them. An uncertain finding gets a second opinion before anyone fixes it. A review finding the reviewer is not sure of is handed to a fresh agent that has not seen the reasoning behind it, and is kept only if that agent confirms it. A wrong finding then costs one check instead of a round of fixes. A profile changes one check of another in a few lines. From 0.41.0 a profile can take over a check of another by its name (covers:), so a Laravel project runs its test suite once. Next, every stock profile names its checks, and a profile builds on another and changes only what differs, instead of copying it; until then a profile under .ai/profiles/ that no active profile reaches stays silent.

After that: new capabilities

Planning that lives in Jig. Jig can be read by a program (0.29.0), planned with (0.31.0) and asked what to take next (0.32.0): a queue holds the priority, order and dependencies of tasks and epics, a running task can be asked to pause, and jig queue next advises the next task from them. From 0.45.0 a task nobody started is paused directly, and your agent offers the task jig queue next names. What is left: a way for jig init to tell an installed Jig UI about a new project. Reviewing somebody else’s pull request. Give Jig the address of a colleague’s pull or merge request on GitHub or GitLab, read the review exactly as it will be posted, say yes, and it lands as one comment-only review; after the author’s fixes, a follow-up answers its own earlier comments. All of it is in 0.42.0; from 0.44.0 each finding carries its severity and a number, and the skill is installed for you, so it works in any clone. What is left is checking GitLab’s posting, the follow-up and the severity layout on a live merge or pull request. Git flows. A project picks how its tasks travel: direct, straight to the main branch, or staging, where a task lands on a staging branch through a reviewed pull request, waits there parked while QA tests it, and reaches the main branch on “prepare for prod”, said by a person or run by CI. All of it is in 0.45.0 (Test on staging first). What is left is running it on a real project, GitLab included (task staging-flow-field-check); deciding whether an epic’s work passes through the staging branch, once a real epic meets one (task epic-in-staging-flow); and telling a squash merge, into the staging branch or out of it, from work that is not there (Known issues). Project hooks. A way for a project to bind its own rules and its own checks to stages of the route, so that what a project insists on is asked at the stage it belongs to rather than remembered. A bug fix starts from the failure. For a task that fixes a defect, the route asks for the failure first — reproduced by a test or a written check — then the fix, then the same check again. Defects leave a record, and records become rules. A fixed defect leaves a short structured note: the cause, the kind of mistake, the files. A skill reads many of them and proposes project rules for what keeps recurring; a person accepts or rejects each one, as with any proposed knowledge. This needs a decision recorded first, because it is a new kind of record. Knowledge documents that name each other. An ADR that replaces another, a document that affects another — written as typed links and checked mechanically, so that a replaced decision cannot stay quietly in force. Beyond that, ideas with no start date: a link from each requirement in a specification to the check that proves it; accepting a known failure with a reason and an end date rather than switching the check off; a separate security pass for the riskiest tasks; noticing an unattended run that has gone silent; knowledge shared between several repositories — a task can already read a neighbouring repository’s task or spec (0.38.0), but not its .ai/knowledge/; and knowledge that lives in a section of an existing file rather than a whole one.

Beside Jig: Jig UI

Jig UI is a separate, optional project, in the making: a local page with a board across all your Jig projects, where tasks and epics are ordered and prioritised and new tasks are filed. It reads and changes your projects only through Jig’s own commands and contracts — the JSON form described in Reading Jig as data, and the planning described above — so Jig works exactly as it does without it. What its next phase needs from Jig — the queue, pause requests and filing a task from a program — is in 0.31.0, so that phase can start on it; resuming a paused task from a program is in 0.35.0; the archive and the links between merged tasks are in jig task list --json from 0.37.0; whether a roadmap item counts as done, merged work included, is in jig spec list --json from 0.38.0; jig task list --json no longer starts processes for every field of every task from 0.38.1, so jig task list --all --json on a project with dozens of tasks takes about a second rather than about ten (measured on a synthetic project of 40 tasks; see the changelog); an upgrade’s pull request is in jig status --json, and jig upgrade --land --json brings it in once merged, from 0.39.0, so a program no longer has to remember it; closing a task with the revision it read, the settings as JSON, the knowledge waiting for a person, its decisions and roadmap writes that leave your checkout alone are in 0.40.0; from 0.41.0 a finished task leaves the queue, so the board shows only the work left, and an upgrade from unreleased Jig is refused as unreleased-source; from 0.43.0 an upgrade whose pull request is still open is refused as not-merged, not failed, and a refused close says why GitHub or GitLab could not be asked; from 0.45.0 jig status --json says how far a clone is behind origin and jig refresh brings it up without moving the checkout, a task nobody started is paused directly, and, on the staging flow, each task in jig task list --json says whether it is on the staging branch and why it is parked, and jig task promote is the command a card moved from Staging to Ready can run, with no agent unless the main branch conflicts. Its plans live in its own repository, and its documentation at jig-ui.fapost.in.