The most frustrating thing about using AI is knowing you are about to create a task, then sometimes waiting for it to finish before asking your favourite AI to build the second one.
So you start writing the rest of the program in a notepad… and sometimes you don't, and you forget half the context.
With Singularity, you get two systems that let you write without stopping. They answer the same question — "how do I keep thinking while the AI works?" — from two different angles.
Dependencies: chaining without waiting
The first idea is simple: you can decide that a task cannot start until the previous one is done. You write ticket A, then ticket B, and you declare that B depends on A.
In practice this changes everything about the flow. Instead of sitting in front of the screen waiting for A to finish so you can write B, you empty your head all at once: A, B, C, D, in the order they should chain. Singularity keeps B waiting, starts it automatically as soon as A ships, and so on. The queue unwinds on its own, in the right order, without you coming back to relaunch it by hand.
When the AI catches the dependency you forgot
The most useful part is what happens when you forget to declare the dependency.
You write two tickets back to back, convinced they are independent. But ticket B assumes an API, a screen or a migration that only exists in ticket A. Singularity detects it and flags that ticket B will be hard to handle without ticket A… which then becomes its dependency.
If Singularity warns you that one ticket assumes another, it is because it read both and understood that the second one leans on something the first must deliver first. You stay in control: you accept the proposed dependency or you dismiss it. But you no longer discover the blocker at the worst moment — mid-execution, when the agent hits something that does not exist yet.
Parent tickets: splitting an oversized task
The second system works upstream. Our application prequalifies every ticket it receives. That prequalification lets it split an oversized task — agile-style — to handle it in several passes.
Why split? Because a huge task yields one unreadable commit, an agent that scatters, and a result that is hard to review. Breaking it into sub-tickets gives you separate commits, cleaner content, and keeps each piece small enough for the AI to handle cleanly, in one pass.
A parent ticket is therefore more than a label: it is a mother task resolved through its children. And prequalification does not stop there — it can also make the sub-tasks depend on one another. The two systems meet: the split produces the order, the dependencies enforce it.
Why it changes the flow
Put end to end, dependencies and parent tickets remove the dead time that eats away at working with AI. You no longer stop to wait, no longer open a parallel notepad, no longer lose the context between two ideas.
You think the whole program through, write it all out, and Singularity takes care of ordering and running it in the right sequence. The AI works while you think about what comes next — instead of the other way around.
Intrigued? Come and test it. It's free.
Frequently asked questions
What is a dependency between tickets in Singularity?
It is a rule that prevents a ticket from starting until another one is finished. You declare that ticket B depends on ticket A: Singularity keeps B on hold and launches it automatically as soon as A ships. This lets you write a whole sequence of tasks at once without sitting in front of the screen.
What happens if I forget to declare a dependency?
Singularity reads the tickets and detects when one assumes another. If ticket B relies on an API, a screen or a migration delivered by ticket A, the app flags that B will be hard to handle without A and proposes A as a dependency. You remain free to accept or dismiss the suggestion.
What is a parent ticket?
It is the result of prequalification: when a task is too big, Singularity splits it into sub-tickets — agile-style. The mother task is resolved through its children, which gives separate commits, cleaner content, and pieces small enough for the AI to handle cleanly in one pass.
Do I have to declare dependencies manually?
No, not necessarily. You can declare them yourself when you know one ticket blocks another, but Singularity also detects them automatically at prequalification — including between the sub-tickets of a single parent ticket.