How the agents work together
Pip plans, Nib builds, Moss tests. You always see who is working on your store.
Every task is handled by three agents. Each one does one job, and each hand-off shows up in the task thread.
| Agent | Role | What it does |
|---|---|---|
| Pip | Planner | Reads your theme, asks what it needs to know, and writes a plan you can approve before anything is built. Refuses requests that are outside theme work and suggests a theme-side alternative. |
| Nib | Builder | Writes the Liquid, JavaScript and CSS on a copy of your theme, reusing the styles you already have. Fixes what Moss finds. |
| Moss | QA | Tests every change before you see it: Theme Check, both screen sizes, clicks, checkout and speed. |
Reading their faces
Each agent shows what it's doing. Pip looks up while thinking and leans in with raised brows while waiting on your answers; Nib taps away while building; Moss squints and scans while testing. A worried face with a sweat drop means the task needs your help, a sleeping agent means the task is paused (for example when you're out of credits), dizzy spirals mean a step failed on our side, and a jump with sparkles means your change just went live. They move at their own pace, so two agents on a screen never move in sync. With reduced motion turned on in your system settings, they hold still and only their expression changes.
The flow of a task
- Drafting. Pip reads the relevant files and your store memory, then asks a round of clarifying questions (usually three to six) before writing the plan: where it goes, how it looks and behaves, the wording. When you answer, he carries on from where he stopped, with everything he read still in mind. The questions come one at a time. Pick one or more options, write your own answer, or skip a question and let Pip decide, then submit them together. Clarifying questions cost nothing.
- Building. After you press Build it, Nib starts right away while Shopify duplicates your live theme, and his work lands on that copy. He starts from exactly what Pip read while planning (read again from the copy, so it's never out of date), so he doesn't explore the theme a second time. Before he hands over, he runs Shopify's Theme Check on the copy and checks for bugs QA used to catch, such as a translation escaped twice or a new setting without a value. Every round Nib works on (the build, then any fix or adjustment) adds its own file cards to the thread, showing only what that round changed. Click a card to see that round's diff; All changes shows the whole copy against your live theme.
- Testing. Moss writes the test from Nib's exact changes and runs the QA checks on your real storefront. Flukes are retested on their own. If something really fails, Moss explains why and asks you whether Nib should fix it or it should go to you for approval.
- Waiting for your approval. You review the before and after, the QA report and, if you want, the code diff. To try your own content (your logos, your copy) before approving, use Edit in theme editor on the review card, in the review panel's Preview tab or on Theme versions. It opens Shopify's theme editor on the copy, at the page the change is on. You need a Shopify admin login for the store, and the link shows only to people who can approve, once testing is done. What you change there is part of the copy: it goes live when you publish the copy, and when the task updates a theme you picked instead, Kobold carries your editor changes over to that theme too. Moss tested Kobold's change, not your edits.
- Live. Kobold publishes the copy and Moss re-runs the smoke tests on your live store.
When a check keeps failing, the task moves to Needs your help with what went wrong and a few ways forward. Nothing is published.
A new look instead of a tweak
Pip and Nib tell a change to your current design ("make the heading larger") from a request for something new ("make this section editorial", "like a fashion magazine", a screenshot or a link to a site you like). For a new look, Pip plans a new section that keeps your content, and Nib designs it in that new direction instead of reusing your theme's styles: new layout, type, colors and fonts are all allowed (Shopify's font library first, Google Fonts only inside that section). Attached images and pasted links are references for the look, not content to copy. Pasted links are opened in Moss's browser and screenshotted for Nib. If Kobold can't open one (the site blocks us, it takes too long, or the address doesn't work), Nib stops before building, at no cost, says why, and the task waits in Needs your help: try again, or attach a screenshot instead. Only the place you asked for gets the new section, and the old one stays in the theme. See Canvas.
Changes across many files
When the same change goes into many places (a setting added to every section, a class renamed across snippets, a text key in every language file), Nib can make it in one step instead of file by file. He writes a short script that Kobold runs in a sandbox on the copy. Every file it would change goes through the same checks as a single edit (locked files, hard-rule notes, checkout, file size, valid JSON) before anything is written, and the change is applied all at once or not at all. JSON files (templates, language files, section settings) keep their layout: only the keys that change are rewritten, so the diff shows just the real change. Kobold then runs Theme Check on the changed files, and Nib fixes anything it finds. While he writes it, the status shows what he's on ("Editing 12 files…"). Moss can check many files at once the same way, without changing any. Store-wide canvas changes still ask you first (Go / Cancel) when they reach more than 8 files or 3 templates.
Changing something after it's live
Write in the same thread to change something that's already live ("make the button a bit smaller"), or press Try again with a fix after a rollback. Kobold starts a new round on a fresh copy and builds on what the task already shipped, so you don't have to describe the first change again. Pip and Nib see the earlier plan, Nib's notes and the exact changes that went live.
Before Pip plans, Kobold checks that your theme still has that change:
- It does: Nib builds on top of it ("Nib is building on top of what's live").
- You rolled it back: Nib brings it back on the fresh copy, then makes your change.
- It was replaced or edited since (another theme was published, or someone edited those files in the Shopify admin): Pip asks what to build on. You can bring back what Kobold shipped, or start from the theme as it is now and keep those edits. If only some files changed, Pip lists them. If you skip the question, Kobold brings the change back when the theme lost all of it, and keeps the edits when only some files changed.
If the theme loses the change after Pip planned but before you press Build it, Nib brings it back on the copy and says so in the thread. A task keeps the theme it started from (see Work from theme), so rounds after the first can't switch it.
Test data for QA
Some changes can only be tested with your store's own data. For a discount code field, Moss needs a code that works, one that should be rejected and, when it matters, one that exists but doesn't apply (a minimum spend, say). Pip asks for these in his question round and puts them on the plan, and suggests saving reusable ones to store memory under Testing, so he doesn't ask again. If Moss still finds something missing when he writes the test, he asks you, and QA waits for your answer. Kobold can't create discounts or products, so give ones that already exist.