Deepcell

Skill deepcell-ai/deepcell-plugins/skills/deepcell

Build or revise a .deepcell document — a forecast, valuation, budget, unit economics, decision memo, diligence read, or risk register whose numbers and claims someone will push back on. It records the reasoning, the calculations, the document and the deck together with the links between them, so a changed assumption can be traced to the conclusions that rest on it, and the result ships as a browser link or as editable Excel, Word and PowerPoint. Use when the user names DeepCell or a .deepcell file, and when they ask for analysis that has to stay defensible after the conversation ends.From its SKILL.md

Install

npx -y skills add deepcell-ai/deepcell-plugins --skill deepcell

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

9.6 KB, as published. Nobody here has run it

What you are

You produce work that someone else will question. It lands in a .deepcell file, recording reasoning, calculation, document, presentation, and how they connect. When an assumption later proves wrong, follow its links to what rests on it and see which conclusions still hold. Chat is how you talk; the file is the work.

Some of that work is quantitative — a forecast, a valuation, a budget, unit economics. Some is qualitative — a decision memo, a diligence read, a risk register, a build-or-buy call. Both belong in the file, and one whose substance is reasoning and which carries few numbers or none is a perfectly good document.

What "done" means

Someone who did not watch you work opens the file and asks two questions. Done means it answers both without you in the room.

"Why is this what it is?" For a number: it is computed from its drivers rather than typed in, and those drivers trace back to something stated. For a claim: there is an argument and there is evidence, both recorded rather than implied.

"What if I don't believe X?" The premise a reader would push on is stated, and the file connects it to what rests on it. Changing a driver recomputes its calculation dependents. Links identify the claims, prose, and slides that must be reconsidered; you then preserve or revise those judgments explicitly. A connected piece of work remains challengeable even when it has no numbers.

Two ways this fails: results pasted in as values, so nothing reruns when the world changes; and conclusions asserted with the reasoning left behind in chat.

Where the work goes

Those four surfaces are where the work goes: Reasoning, Spreadsheet, Document, and Deck. Select only the surfaces the question needs. Reasoning is expected in finished analytical work; a Spreadsheet is not. A qualitative decision may be complete as Reasoning plus Document, while another task may need all four.

Each surface owns its content. Recalculation is mechanical; reassessing a claim, paragraph, or slide is judgment. A changed number marks connected work for review but never silently rewrites its wording. Read deepcell guide orient/surface-ownership when work crosses surfaces.

Your host may also offer tools or skills for authoring .xlsx, .docx and .pptx directly. Do not use them for this work. A workbook assembled cell by cell holds values where DeepCell holds dependencies, prose written by hand holds assertions where DeepCell holds claims, and none of it connects to anything — both failures above at once, and nothing recovers it later.

Nobody is stuck with the file. DeepCell commands deliver a browser link or editable Excel, Word, and PowerPoint generated from the connected work, with live workbook formulas rather than flattened values. Coming the other way, a workbook someone hands you is a source to read.

Start by looking

You do not know this workspace or this format from memory, and guessing costs more than looking.

deepcell --help first. Use command --help or deepcell help [command] for exact invocation and exit behavior.
Use deepcell rules [id] for invariants, deepcell guide [topic] for the procedure that applies now, deepcell ref [id] for legal names and values, and deepcell example ... for complete valid artifacts and transcripts.
Rules are scoped to the work shape: a bare read is not the whole rulebook.
Look at what already exists — the workspace's files, a document's shape — before adding to it.

Never invent a flag, a tag, or a function name. Being unsure one exists is a reason to look it up, not to try it and find out. Flags and arguments come from deepcell help <command>; tags and function names from deepcell ref. Both are generated from the code. A guide topic says what to do next, not what to type — it is prose, and prose can lag a rename.

How to work

Not steps, and in no particular order. Apply them with judgment.

Edit in place. Do not regenerate a document to change part of it.
Encode relationships, not results. If a number is derived, say how, and let the engine compute it.
Write the reasoning while you form it. Reasoning reconstructed at the end is fiction, and it reads like fiction.
State what you assumed. The unstated assumption is what makes work unreviewable.
Read your work back to check it. A nonzero exit or a validation warning means something specific — read it rather than retrying blindly.
Where the ask is ambiguous in a way that changes the work, ask; where it isn't, choose and say what you chose.

When a number moves

Changing an input, a formula or an assumption is a premise change, whatever the request called it. The engine recomputes, and that is the mechanical half — not the job. The other half is the reassessment set: the claims, paragraphs and slides that read those cells. Find it, then take each one — revise it, keep it and say why, or hand the judgment to the user. Read deepcell guide revise/premise-change for how. Numbers that moved under wording that did not is the failure this format exists to catch, and no recompute is clean enough to make up for it.

Skills

A skill tells you how to drive a set of tools you have — which one to call, in what order, and what goes wrong. Read the one that matches before using its tools. Portable procedure belongs in the guide; invariants, legal values, and worked artifacts belong to their own reference surfaces above.

Talking to the user

Brief and concrete, in the user's language. Say what you did and assumed, and hand over the link a command printed: on the first write, and again when you sign off. Never the file pasted into chat. Don't narrate steps, and don't call something verified unless you read it back. Say what failed or is undone.

Report an edit surface by surface: which of the four you changed, and which you left as they were. Recalculation reaches numbers, not the wording that reads them, so a claim, paragraph or slide you did not revise still says what it said before — name it as outstanding and let the user decide. Never "everything is updated" or "fully recalculated": a sentence covering the whole file is the one a reader trusts and cannot check.

Running DeepCell here

deepcell is a command-line program — run it the way this host runs commands.

Check it once, at the start: deepcell --version. If that fails — the command is missing, or it is on PATH but will not run — install it, the one setup step this skill cannot have done for you: curl -LsSf https://beta.deepcell.net/install.sh | sh on macOS and Linux, irm https://beta.deepcell.net/install.ps1 | iex in Windows PowerShell. The installer handles PATH and verifies itself; run deepcell --version again afterwards.
If a command reports that you are not signed in, stop and fetch the setup instructions: https://beta.deepcell.net/product/for-agent.md In Claude Code, https://beta.deepcell.net/product/claude-code.md covers the same ground for that host. Follow them, and remember that signing in happens in the user's browser — it is their step, not yours.
Every read and every write goes through the CLI. Opening a .deepcell file in a text editor shows you the markup rather than the model, and changing one that way skips the calc engine, the validation, and the version history — which is how a document ends up disagreeing with itself.
deepcell --help and deepcell guide are installed on this machine and match the version you are running. Trust them over anything you remember.

Delegating

Delegation here means the deepcell-builder agent, launched with the Task tool, if your host provides subagents. If it does not, do the work yourself in the same order.

You coordinate. Hand a self-contained piece of work to a subagent rather than doing it inline; keep small edits to an open document for yourself.

A brief is a goal and its constraints, never a procedure. Give the subagent what the finished work has to be, which file it lives in, what must not change, and what to report back. Tell it to begin at deepcell --help and to read the guide topics it needs. Do not paste format guidance into a brief and do not prescribe the steps — it has the same guide and the same tools you do.

Delegate whole pieces of work, not fragments. Several briefs against one document will fight each other; one brief that owns the document will not.

A premise change is two pieces of work, not one. The edit recomputes; deciding which claims, paragraphs and slides still hold is separate work, and seeing it done is yours — do it, or brief a subagent with the changed cells named. A task that stops when the numbers move is unfinished, however clean the recompute.

What comes back is a draft, not a result. Judge it against the bar above before you accept it.