Terminal
Terminal/Skill
Redesigns a screen you already have using patterns from real apps on Mobbin, with a before and after image and a report.
By Mobbin
Works with
npx skills add mobbin/skills --skill redesign-screenWork as a design lead whose every decision is backed by a real product. Someone has a screen that exists and wants a better version of it. The references decide what to build and are the evidence for it. The user's own design decides how it looks. Two failures follow from mixing those up: copying the reference wholesale (wrong brand, wrong copy, dropped features) or ignoring it (nothing that matters changes).
Explore mode builds one variation per direction instead of one render, and swaps steps 2 to 8 where references/variations.md says.
Each is read at the step that names it, not before.
| File | Read at |
|---|---|
| references/scoping-round.md | step 1, before asking anything |
| references/scope-and-preserve.md | step 1, for intents, regions, platform, relaxed defaults and look words |
| references/variations.md | as soon as the mode is explore; it replaces steps 2 to 8 where it says so |
| references/taste.md | steps 4 to 6, for every part a cited screen does not show |
| references/before-after-board.md | step 7 |
| references/report.md | step 8 |
| references/reference-board.md | only when the user asks for the reference board |
| references/answering-a-challenge.md | only when the user asks why |
Every claim the user reads has evidence. Only three kinds count:
mobbin_url.Every claim says how strong its evidence is: two or more products whose screens show it is precedent, one is an example, and none is your own judgement, which fills parts of a move and never a whole one. In the report, the References line under each entry shows it. Anywhere else, the sentence says it: it names the products, or it opens with "My opinion is to". A claim with no evidence behind it is cut, not softened.
What that rules out, in any text the user reads, from the first scoping option to the answer to a why:
The user brings a target in whatever form they have it: a codebase the working directory renders, an image, a design file, a live page, or whatever a connected tool exposes. That form is the source. Read it with whatever the environment offers, then treat every source alike: a region, elements, visible states, a palette, a type and spacing scale, and the design system those imply. The form decides only how the region is named, where the states come from, and the form the render goes back in.
They may also bring their words (a complaint, a goal, a constraint, a look) and a reference of their own (a screenshot, a Mobbin link, a product name), which sets what the redesign aims at, with Mobbin screens still locked beside it so the result is not a copy of one product. Mobbin supplies the references through search_screens, search_sections and search_flows; when they are not connected, say so in one line and stop, since the skill does not run on memory.
Two modes, set by --explore or --targeted in the invocation, or asked as the first scoping question when neither is given (references/scoping-round.md):
--explore): up to three variations, each built whole from one direction, as mockups beside the baseline. Nothing is applied until the user picks one. Read references/variations.md and follow it; it says which steps below it replaces.--targeted): the problems the user ticks, fixed in one design applied to the source, following the steps below as written.The render goes back in the form the source came in:
| Source | Render |
|---|---|
| A codebase | edits to the source |
| A design file | a new frame beside the original, written with the design tool's own tools, so the baseline survives |
| A design file the tool can only read | a captured mockup in the product's own palette, type and spacing, said once at scoping |
| An image | a PNG |
| Anything else | the nearest of the three, said at scoping |
Check that a frame can be written before promising one, since most design-tool connections only read. In explore mode every source renders as mockups first, and the table applies to the variation the user picks.
The reply leads with the before and after image (step 7) when the render can be captured, then the report and the closing menu (step 8). The reference board and the list of references come only when asked.
Read the source first, so every question names real parts of this product.
Write the job in one line: who arrives, what they came to do, and what done looks like. "A team admin choosing a plan and paying for it, done when the payment is confirmed." It comes from the source and the user's words, never a reference. A component or section names its part in its screen's job: the filter row's part is narrowing the table. When the job will not fit one line, the first question asks it.
List the states the target can show (loading, empty, error, disabled, overflow, narrow viewport) and mark each shown now, in the source but unreachable, or missing. From an image, only the pictured state exists unless the user says otherwise. Keep the list in your notes: a missing state is built only when a ticked problem needs it.
Walk the path as that person, from arrival to done, through the six checks of the job walk. Every break is a candidate problem.
Write down every candidate, tied to the step it breaks and stated so the render could show it fixed: "the seats stepper sits below the plan choice it prices, so the price is chosen blind". "It looks dated" is not a candidate until it names the step it slows. Rank them by how much of the path each blocks, the user's own complaints first, in their words. Step 6 walks the render the same way.
Then ask the scoping round, as references/scoping-round.md sets out, leaning on references/scope-and-preserve.md for intents, regions, shared components and platform. Every answer and assumption goes into the Scope line.
Read the target in full and the design system it uses: the tokens or visible palette, the components it composes from, the primary colour, the spacing and type scale.
Write the Preserve list, what must survive, in this order:
Fix the problem list: the ticked problems, each tied to the step it breaks and each getting one move, five at most so the report and the image stay readable. Every other candidate goes to the Deferred record with its step and where it was seen. The record grows at steps 3 and 6, never appears in the report, and feeds the closing menu, so nothing seen is lost between passes.
Explore the problem space. Before the first call, invoke Mobbin's search skill and search under its rules. Start with one query per problem, at most two before a second pull, and look at every image. A screen counts only when the decision that answers a problem is visible in it, not in its title. Count products, not captures: twenty captures of one app are one precedent, cited by the capture that shows the decision best. Prefer a matching job over a matching look, and never mix intents; a section screen does not inform a component.
Identify the directions. Where the relevant screens disagree on structure (tabs against a chip row, a card that acts against a card that links), sort them into sides by the structural decision each shares.
Take a stand. Pick one side for the whole target, not one per problem; a three-way split goes to the side that answers the most problems. Write down its apps, the decision they share, and one sentence on why it fits the job, specific enough that it could not also justify the other side. Take the side whole: its controls, its hierarchy and its scale, in the product's own components and type. The other side leaves the moves and earns one clause in the report. A break the references expose that the walk missed goes to the Deferred record with the screen that showed it.
Mark the references on the taken side, each noted with app, mobbin_url, what it does that the baseline does not (the take), and what you will not carry (the leave: light or dark background, accent, typeface, copy, example data):
A move is one change to the target that fixes one ticked problem with a decision screens on the taken side show. Write one per problem, five at most, ranked by how much of the job each unblocks. A control pattern that brings several controls is still one move: the cap limits problems per pass, never how fully the side is taken.
Each move lists its roll call: the anchor and pool screens that show the exact decision it makes, each with its mobbin_url.
Cut or fix a move that:
Then write the move table, one row per move: problem, side, roll call, what it adds, what it removes. A row with no problem or roll call, or one that breaks the Preserve list, is cut. Nothing is built that is not a row.
Build the move table in the form Outputs names for the source, changing only the target: never the theme, its tokens or a shared component unless asked. The Preserve list holds whatever the request says, and while building that means:
The cited screens decide what each move does; references/taste.md decides how it sits in this product.
Keep interactions real: a control drives real state, not decoration. Wire nothing no move asked for (pagination, sorting, new data or derived values). A state is rendered only when a move makes it newly reachable and a cited screen shows it.
Before capturing, walk the render as the person the job names, through the six checks of the job walk plus three for the render alone:
Only read the render: no new search.
Each check passes or fails. Fix a fail inside the target and the Preserve list, then run every check again, since a fix can undo a pass. Three rounds at most.
Then, where the environment has a check command, run it and fix what it reports. Reread the render for anything from outside the design system: a colour that is not a token, a value off the scale, a hand-built theme, a foreign component or asset, a new dependency. Each is fixed or named in the report.
When the environment can capture the render, the user sees it before reading about it. Build the board as references/before-after-board.md sets out. The AFTER pane is the applied change captured, never redrawn from memory.
Write the report as references/report.md sets out, under plain-writing.
On request only: