More than one conversation
Putting a piece of work down and starting the next one cleanly — what the builder keeps, what it forgets, and when a fresh conversation is the right move.
An application lasts longer than any one piece of work you do to it. The conversation that took a stock list from nothing through eleven corrections is not a good place to ask for an invoice layout.
So an application can have several conversations. One is on screen at a time, and the bar above the conversation says which.
Starting one#
Open the conversations menu — the name at the top of the conversation — and choose Start a new conversation.
You are in it immediately. The hand-over described below takes a few seconds to write, and it is written while you are already in the new conversation rather than before you get there — you will see Carrying over where this application got to… at the top while it is being written, and the note itself when it lands. You can start typing straight away.
What the builder takes with it#
This is the part worth understanding, because it is the whole reason to do it.
A new conversation is a clean slate. The builder no longer re-reads the earlier exchange. What it reads instead is:
- the application's code, in full, as it stands — which is where nearly everything you asked for actually ended up;
- a hand-over note: a short written summary of where the application got to, what was decided deliberately, and anything left unfinished.
You can read the note yourself — Carried over from earlier work, at the top of the new conversation — so there is no question about what the builder was told.
If you send your first message before the note has finished being written, the build waits for it rather than starting without it. That wait is a few seconds against a build that takes minutes, and starting without the note is the expensive half of the trade.
If you want a genuinely clean slate#
Open Carried over from earlier work and press Do not use it.
The builder then reads this application's code and nothing else — no account of what was decided before, no note of what was left unfinished.
That is worth doing when the earlier work is the problem rather than the context: a stretch that went wrong, an approach you have abandoned, a direction you do not want argued back at you. Inheriting a careful summary of a bad afternoon is inheriting the bad afternoon.
The note is not deleted. It stays in the conversation, struck through and marked not being used, and Use it after all puts it back. Both take effect on the next build, not retroactively — a build already running was given its history when it started.
Why bother#
Two reasons, and the first one is money.
A long conversation is re-read on every turn. Nine months of settled argument is re-read before the builder answers your next question, and you are billed for reading it. A fresh conversation is markedly cheaper and quicker for the same request.
It also answers better. A builder holding four hundred exchanges about a stock list is a builder that keeps bringing up the stock list. Asked for an invoice layout in a conversation of its own, it reads the job in hand.
When to start one#
- The work has visibly changed subject — a different part of the application, a different audience, a different problem.
- The last piece of work is finished and deployed, and you are starting the next one.
- Builds have begun feeling slow or expensive relative to what you are asking for.
When not to#
- Mid-argument. If you are three corrections into getting one screen right, the detail of those corrections is exactly what you want kept. Starting over makes the builder re-derive it — or fail to.
- Because something went wrong. A fresh conversation is not a fix. See When a build fails.
- Out of tidiness. One long conversation is not a problem to be cleaned up. Most applications never need a second.
Going back to an earlier one#
Pick it from the same menu. Everything said in it is still there, and it reads exactly as you left it.
An earlier conversation is read-only. The composer is closed, and the bar says earlier work with a way back. This is deliberate: a message sent into a conversation that has been put down would be answered in a conversation nobody is looking at.
Press Back to now to return to the one work goes into.
Naming them#
A conversation is named after the first thing you asked of it, which is usually good enough to recognise it by. Rename this one… in the same menu gives it a name of your own, and once you have named one the builder never renames it.
Reading a long one#
The conversation loads its most recent exchange and fetches the rest as you scroll up, so opening an application that has been worked on for a year is as quick as opening one built yesterday. Show earlier messages at the top fetches the previous stretch if you would rather press something.
Scrolling up while a build is running stops the conversation following it, so you can read without being dragged along. Latest, bottom right, goes back to the newest message and starts following again.