Thinkube Tandem
Build your first application change with Tandem
Write what you want in plain sentences, see how they were read, sign the promises, and get the change running in your app
- Level
- beginner
- Time
- 1 h
- Risk
- low
- Updated
- 2026-10-29
Overview
Basic idea
You say what you want in the words you would use with a person. Tandem turns the words into promises (what will be true when the work is done), proves each promise with a check written before the code, builds the change, deploys it and tells you, sentence by sentence, what happened.
-
Reading only shows; nothing is saved until you press Keep. Tandem shows how it understood each sentence, so a misreading costs one press.
-
Your words are the record. Once kept, your sentences are never edited by the machine; everything derived from them can be made again.
-
Signing freezes what runs. The run builds exactly the promises you signed.
-
The report answers your sentences. Each sentence gets one word, with the checks that proved it.
-
The decisions are yours. Only you can keep, sign and accept. Claude Code can write the sentences. Tandem gives it no tool for the rest.
What you’ll accomplish
You make a todo app from the web app template, write nine sentences about it, and build the first of the things Tandem groups them into, until it runs at the app’s address.
What to know before starting
Required
-
Thinkube IDE open, with the Tandem icon in the activity bar.
Optional
-
Thinkube Tandem: how a sentence becomes a promise, and how a run works.
-
The words on the page: every label and state word.
Supported hardware
-
GPU: not needed. Tandem’s model rounds call Claude, and the app is built and deployed by the platform like any other.
-
Architecture: amd64 or arm64.
Prerequisites
Platform
-
Thinkube running, with Thinkube IDE open. Ask Claude: "what’s running?"
-
A repository Tandem knows. The walk made one: "make an app called todo from the web app template". For a repository you already have, run Tandem: Activate Repository.
Components
-
None beyond the base platform.
Instructions
Step 1. Make the app and open a space
A thinking space is one page where you write your sentences and follow their work. You only ever look at that page.
Ask Claude:
› make an app called todo from the web app template
Claude creates the repository and activates it for Tandem.
Then click the Tandem icon. Under Projects, your repository lists its thinking spaces; choose New thinking space…. The space opens in its own editor tab. Across the top is the strip: one line saying where you are and one button, the next thing you can do.
Step 2. Write your sentences
Type what you want, one line per thing, in the words a person would use. Writing costs nothing: the line under the box says one line is one ask · Enter starts another · Ctrl+Enter reads · nothing is recorded by reading.
Or ask Claude: "put these lines in the box of a new thinking space", followed by the lines. Claude puts the lines in the box.
The nine lines of the walk:
My tasks come back in a sensible order — what is due soonest first, and high priority above low — instead of whatever order the database felt like.
A task that is past its due date is obvious at a glance, not grey small print.
Finished tasks stop crowding the ones I still have to do.
I can see how many tasks I have without counting cards.
I can look at just the high priority ones when I want to.
When I open the new-task box the cursor is already in the title, so I can just type.
I can add a task with the keyboard alone — type a title, press Enter, done.
If I try to save a task with no title it tells me, instead of doing nothing.
Deleting a task asks me first, because one mis-click should not lose work.
The strip then says 9 lines written, not read.
Step 3. Read these 9
Press Read these 9. Every sentence comes back with the two parts the machine read in it: the subject highlighted, the claim (what must become true of it) underlined. What I read in your words lists the subjects, my tasks, the new-task box, deleting a task, with how many claims each carries.
A sentence that never names its subject shows the subject in brackets and names nothing. If the reading is wrong, change the words and press Read it again.
Step 4. Keep these 9
Press Keep these 9. The page your sentences opens with the nine sentences, each with a pencil to say it differently and a plus to amend it.
Step 5. Group into things to build
Press Group into things to build. Each thing gets a name, the sentences it carries, and a suggested order: first, then, later. Proposing decides nothing.
On the walk the nine sentences became three things:
| Thing | Sentences |
|---|---|
I can see at a glance what still needs doing |
1–5 |
I can add a task without leaving the keyboard |
6–8 |
I cannot lose a task to a mis-click |
9 |
Step 6. Build the first
Press Build the first. The strip counts working out what to build — N of M subjects done. When the last subject is done, the page what it will do opens.
Under What will be true when this is done it shows one promise for each claim, the files it lands in, and under each promise the lines that must become true, each with where it stands:
-
checked when it is built: a check, written before the code by a worker that never sees the code, will prove it;
-
judged by a reviewer at delivery: a reviewer reads the finished work once;
-
only you can see this: only the running product can show it, and you confirm it.
Every thing also carries the promise The documentation says what "<the thing>" does, in the words of the person using it. It lands a page in the project’s docs/ folder. Press Not needed on it, with your reason, when no page applies.
Step 7. Sign: Build these N
At the bottom of the work page, Pressing Build these N says what the press does. It signs this work and locks the sentences behind it. It records the machine’s own answers to the open questions. These are the choices your sentences left open, listed as N things I decided for you. It starts the workers and pushes a branch. Nothing is merged until the delivery.
Before it signs, the press checks that the repository is ready. Its setup must hold on a clean copy of the last commit, and a check must land where the repository’s own tests run. A repository that says where it answers (spec.deploy.at) must also declare its live checks (spec.deploy.live, see Live checks). For a template, more is checked. It must declare how it deploys (spec.deploy with run and at). Its newest release tag on origin must name the version in thinkube.yaml. The secrets its manifest.yaml names must exist in Thinkube Control. Its deploy must go live and answer at its health path. When something is not ready, nothing is signed, and the refusal under the button says what to fix. The same commit is not checked or deployed twice: the answer is kept in the store, and Readiness above the button shows it for the commit you are on.
Where checks land follows thinkube.yaml. Each container is a part of the repository with its own tests, and test.one says how one of its test files runs. A container built from the whole repository (build: .) gives the command for every file no other part holds. A check for a screen goes to the part whose tests are written in the screen’s language, even when the screen’s file sits inside another part.
For a template, the build Tandem runs is only the build the repository declares. The image is built, and its tests run, only by the platform’s deploy, so the deploy is what decides whether a template’s work holds.
Press Build these N. The strip says building — <the thing’s name>, the run page opens, and Stop is the only other button.
Live checks
Some promises only the running service can answer, for example the storage service returns the document’s XLIFF for a key. A test in the worktree cannot answer them, and a browser cannot call an API. A live check can. Declare where live checks are kept and how one runs, beside the deploy in thinkube.yaml:
spec:
deploy:
run: ./scripts/deploy.sh
at: https://storage.example.com
live:
home: live
one: "python3 -m pytest -q -p no:cacheprovider <file>"
-
homeis a directory of its own. It must not be inside a directory your unit tests run from, because live checks need the network and the deployed service. Readiness refuses a home inside the directory that holds your unit tests, or inside a part of the repository, and says why. A test runner that searches the whole repository must be told to leavehomeout, for example pytest withtestpaths. -
oneruns one live check.<file>is replaced with the check’s path.
For each promise that only the running service can answer, the tester writes a live check under home. The check calls the deployed service through its public API. It creates its own data under unique names and removes it afterwards. It never imports the repository’s code. The closing gate does not run live checks. When the work is live, each one runs with one in the delivered tree. Its environment has TANDEM_LIVE_URL (the value of at), THINKUBE_CONTROL_URL and THINKUBE_API_TOKEN. Exit 0 turns the promise green. A failure turns it red, with the end of the check’s output, and the run repairs the work and runs the check again. A check that could not run at all (the command is not found, nothing was collected) leaves the promise unjudged and says why.
Without spec.deploy.live, these promises stay pending and say that no live checks are declared. They never turn green.
Step 8. Watch it build
The page the run shows one card per piece of work, titled with the promise it keeps, with a state word: ready, running, needs you, passed, failed, never ran. The header counts N of M workers done · N of M judged on the running product.
needs you means a worker stopped on a question only you can answer, about what you want. The page offers a box and Send. The run is a process of its own: closing or reloading the window does not end it.
Step 9. Read the report
When the run ends, the strip says where it ended, such as built, deployed and running at <address>. The report opens with one paragraph in plain words, then What you asked for, and what happened: each sentence with a word, and under it the checks that proved it.
On the walk the first thing ended with 23 checks passed, and the four reviewers on the running product judged 14 lines. Further down, What the work noticed, and did not do lists what the reviewers saw and did not settle.
Step 10. Decide
The buttons at the end are yours:
-
Go on to the next closes this thing and moves to what is left to build.
-
Take it back out reverts this delivery’s merges and pushes.
-
Run it again starts the signed work again; nothing you wrote changes.
Press Go on to the next. The strip offers Build the first for the next thing, and the path from Step 6 repeats. When the last thing is built, the strip says 9 sentences · everything is built and every sentence reads built and accepted — it is in the project.
Step 11. Next steps
To undo: On the report, press Take it back out.
-
Build the improvements Tandem’s reviewers suggest: the reviewers' findings as the next sentences.
-
The words on the page: every state word on the run and the report.
Troubleshooting
| Symptom | Cause | Fix |
|---|---|---|
After Claude made the app, Projects still says no repositories yet |
The tree reads the repositories when the window loads |
Reload the window; the new repository appears with its spaces. |
In a freshly opened window, the first click on a space in Projects opens nothing |
The extension is still starting |
Click again after a few seconds. |
Build these N says documentation is needed |
Every thing carries a documentation promise, and neither its page nor Not needed is there |
Press Not needed on the documentation promise with your reason, or let the page be built. |
Build these N says not ready to sign |
The repository fails a readiness item: its setup, where checks land, its live checks, or, for a template, its deploy, release tag or secrets |
Fix what each named item says, commit, and press again. |
A promise says no live checks are declared |
The promise can only be answered by the running service, and |
Declare |
A template’s delivery says its promises are pending after Accept |
Those promises are settled by deploying the template, and that deploy did not run or did not answer |
Fix the deploy, then press Ask the platform again. Its deploy runs, and each promise turns green or red. |
A card says needs you and nothing moves |
A worker stopped on a question only you can answer, about what you want |
The card offers a box and Send. The status bar says needs an answer until you do. |
The report says "the reviewers are locked out, so none was started" |
The reviewers' browser could not sign in to the running product |
Open the address yourself and sign in. If that works, press Run it again; the lines they would have judged read not judged until then. |
Take it back out is refused and names a commit |
A commit of your own, made outside Tandem, sits on top of the delivery |
Move that commit aside first; taking the delivery out would take it too. |