MiniMax Code Built-in Skills: The Complete Catalog

Last checked and updated: August 25, 2026

Catalog audited from the MiniMax Code v3.0.67 desktop bundle on August 25, 2026.

A skill is a reusable instruction package. It tells the Agent when a workflow applies, how to execute it, what to verify, and where to stop. A skill can also route to scripts or detailed reference files only when they are needed.

That does not mean a skill magically supplies every dependency. A browser skill still needs its browser tooling. A Lark skill still needs the correct account and authorization. A document skill may need a renderer or office utility. A deployment skill still needs a valid website and explicit publication confirmation.

This lesson catalogs all 21 skill directories found in the v3.0.67 desktop bundle used for this audit. It is a dated snapshot, not a promise that every account, platform, future release, or regional build shows exactly the same list. A top-level packaging manifest repeats code-review; it does not create a twenty-second named skill.

Some bundled instructions use the name Mavis for the local runtime behind Agents, sessions, memory, schedules, hooks, and skill management. In this course, that is implementation terminology inside the current bundle—not a separate desktop product learners must install.

Three states beginners often mix up

State	What it means	What to check next
Skill is listed	MiniMax Code has instructions for the workflow	Read its description and boundary
Skill loads	The Agent can use those instructions in this session	Confirm required tools and files exist
Workflow can finish	Tooling, account access, permissions, dependencies, and inputs all work	Run a harmless smoke test and verify the artifact

Use a skill because the job matches it—not because its name sounds powerful.

The complete v3.0.67 catalog

Code, review, and project setup

Skill	What it does	When it is useful	Important boundary
`code-review`	Reviews a user-named code scope for concrete correctness, security, performance, or maintainability defects and reports tight file/line findings	Reviewing uncommitted changes, a commit, branch, pull request, file, or function	Review is read-only unless fixes are also requested. It is not ordinary explanation, debugging, or implementation, and it must honor the comparison base you name.
`init`	Inspects a real code repository and creates a root `AGENTS.md` with evidence-based setup, test, build, style, and security guidance	Bootstrapping an AI-ready code project or responding to `/init`	It is coding-specific, not for an empty/non-code folder and not for creating a standalone Agent. If `AGENTS.md` exists, the workflow must pause for skip, backup-and-overwrite, or diff direction.
`llm-call`	Sends a raw prompt to a configured provider/model through a local script	Prompt tests, direct model calls, or provider/model comparisons	It is not normal MiniMax Code Agent execution. It needs a configured model/provider and surfaces errors rather than silently switching models.

Browser, desktop, and connected tools

Skill	What it does	When it is useful	Important boundary
`control-in-app-browser` (beta-gated)	Operates the current task’s right-side in-app Browser: inspect, navigate, click, type, upload authorized files, capture screenshots, and test local pages	The user explicitly asks for the in-app, embedded, right-side, current, or FilePanel Browser	Requires the `browserUseTooling` beta gate. Passive reading does not authorize interaction. Authentication stays with the user, and final send, submit, publish, delete, purchase, transfer, or account/permission changes require exact action-time confirmation.
`cu-desktop` (beta-gated)	Guides Computer Use through screenshot → act → verify loops across desktop applications	A supported Computer Use mode task genuinely needs GUI operation outside the in-app Browser	Requires the `cuMode` beta gate and is auto-injected when that mode is enabled. It must not type credentials, bypass security prompts, or perform destructive actions without confirmation. Coordinates are observations, not durable memory.
`mcode-tools-master` (beta-gated)	Discovers, inspects, and calls Connector tools from Bash, especially for pipelines, batches, local files, and multimodal generation or understanding	A connector call must be combined with scripts, pipes, loops, batch automation, or media/document generation	Requires the `mcodeTools` beta gate. Ordinary direct plugin/MCP calls should use the available tool directly. The Agent must inspect schemas, must not invent arguments, and should surface auth failures rather than retry blindly.
`lark-tools`	Routes Feishu/Lark calendar, messages, contacts, tasks, documents, sheets, Base, wiki, mail, and related work through the official `lark-cli` plus runtime channel binding	Any Feishu/Lark request or link, including read-only document and sheet links	Account binding, OAuth scopes, and the official CLI are separate requirements. Do not treat a web fetcher as the right reader for protected Lark URLs, and do not send or mutate data beyond the user’s authorized request.
`x-link-reader`	Reads public X/Twitter posts or profiles through the read-only FxTwitter API when direct fetching is blocked	Summarizing a supplied public tweet/profile or recovering from X anti-bot fetch failures	Public posts and profiles only; no search, timelines, batch, private accounts, posting, liking, or other write actions. Third-party API output is evidence to verify when a claim matters.

Research and visual explanation

Skill	What it does	When it is useful	Important boundary
`deep-research`	Runs a strict five-stage flow: background, direction, analysis/plan, research/verification, then final writing with sources	Open-ended, time-sensitive, fact-heavy market, technical, competitor, policy, academic, or trend research	It is not for simple facts, code edits, log inspection, or routine repository work. Stages cannot be skipped or delegated, and the final answer must not expose internal step prompts.
`visual-page`	Creates a self-contained visual HTML page using diagrams, charts, timelines, comparisons, or interaction when prose would be weaker	Architecture, sequence, comparison, map, timeline, simulation, or explicit “show me as a page” requests	It produces an HTML artifact, not a Word/PDF/PowerPoint deliverable. Data correctness, accessible structure, responsive layout, and working local references still need verification.

Office files and structured deliverables

Skill	What it does	When it is useful	Important boundary
`docx`	Creates, templates, edits, fills, reads, repairs, and compares Word documents with route-specific rendering and validation	Formal `.docx` reports, contracts, letters, templates, or document diagnosis	Not for PDF, PowerPoint, or casual plain-text drafting. It must select the correct route and preserve template structure rather than treating DOCX as plain text.
`pdf`	Generates, reformats, fills, reads, extracts, and OCRs PDFs, including Markdown/LaTeX conversion	A PDF is the primary input or required output	Not for DOCX or PPT. Non-trivial files need location-first inspection, route-specific guidance, and rendered verification; extracted text alone does not prove layout.
`pptx`	Reads, audits, creates, imitates, and edits PowerPoint presentations while preserving layouts when requested	Slide extraction, theme inspection, new deck generation, or targeted presentation edits	A `.pptx` file remains the required deliverable. It must distinguish editing, template imitation, and from-scratch work and visually inspect slides, not only text.
`xlsx`	Reads, edits, creates, recalculates, and converts spreadsheet formats with formulas, formatting, charts, and data cleaning	`.xlsx`, `.xlsm`, `.csv`, or `.tsv` is the main input/output	Not for a document that merely contains a table. Derived spreadsheet values should remain live formulas where appropriate, and formula recalculation plus workbook QA are required before delivery.

Websites and publishing

Skill	What it does	When it is useful	Important boundary
`deploy-website`	Builds or stages an existing local website or standalone HTML page and publishes its first public release	The user asks to launch a local site or page at a public URL	The target must be inside the workspace or safely snapshotted, the build must produce a valid root `index.html`, and publication needs confirmation after disclosing public visibility and private source upload. The workflow says there is no secrets scanner.
`edit-deployed-website`	Edits and republishes an already deployed site in place using trusted desktop edit context	Revising, redesigning, or fixing an existing deployed site	It is not the first-deploy path. It needs the supplied `node_id` and workspace source, must test/build, must warn about source upload and absent secrets scanning, and requires explicit publication confirmation.

Agents, runtime, plugins, and reusable workflows

Skill	What it does	When it is useful	Important boundary
`create-agent`	Creates one on-disk Agent with a responsibility-based name, precise scope, working rules, and measurable stop condition	The user explicitly asks for or approves a new recurring specialist role	It must not load merely to suggest an Agent, decide whether one is needed, create a skill, edit an existing Agent, or delete one. Overlapping ownership makes routing unpredictable.
`mavis`	Routes work about the local Agent runtime: Agents, sessions, memory, schedules, hooks, messaging routes, and skill management	Operating MiniMax Code’s underlying Mavis runtime or understanding those lifecycle surfaces	It is a router, not an external business system. Each subproblem requires its matching reference; memory uses the native memory surface, and most runtime operations should not shell out.
`plugin-creator`	Creates or repairs a local MiniMax Plugin V1 package containing Skills and/or MCP servers	Building a local plugin for the active MiniMax Code data directory	It does not publish to the official Marketplace, create another assistant’s plugin, or support local App-only plugins/hooks. It must not invent endpoints, executables, credentials, or providers.
`skill-creator`	Turns a new repeatable workflow into a scoped skill, lints it, and compares an eval run with and without the skill	A proven workflow should become reusable and no existing skill already covers it	New skills only. It must check for overlap, choose user/Agent/project scope, keep instructions concise, lint, and complete at least one eval where the skill is not worse than baseline.
`skill-refiner`	Applies the smallest evidence-backed correction to an existing skill	A failure trace shows wrong, outdated, or missing skill instructions	Not for new skills, unsupported “make it better” requests, style-only edits, or Agent failures where the skill was already correct. Built-in/project runtime copies are treated as read-only; changes belong in source control.

Count them: 3 code/setup + 5 browser/connected + 2 research/visual + 4 office + 2 website + 5 Agent/runtime = 21.

Beta-gated does not mean “bad” or “enabled”

Three v3.0.67 skill manifests contain explicit gates:

Skill	Gate in the audited bundle	What the gate tells you
`control-in-app-browser`	`browserUseTooling`	The instruction should appear only when that browser tooling is enabled
`cu-desktop`	`cuMode`	The desktop-operation guide belongs to Computer Use mode
`mcode-tools-master`	`mcodeTools`	Connector CLI orchestration depends on the mcode-tools beta capability

The gate is a packaging/runtime condition, not a safety waiver. If a beta skill is absent, do not imitate its internal tool calls or tell the Agent to pretend the tool exists. Use a supported alternative or stop at the unavailable boundary.

The public MiniMax-AI Skills repository also labels that separate open-source collection as Beta and warns that skills, APIs, and configuration can change. Do not assume that repository and this desktop bundle have identical contents or versions.

Step-by-step scenario: choose a skill for a release note

Scenario: You have a small local code change and want defects identified before you decide whether to fix it. You do not want the Agent to edit, commit, push, deploy, or open a browser.

1. Classify the deliverable

The result is a review report, not an implementation. The obvious owner is code-review.

2. Reject nearby skills

deep-research is unnecessary because this is local code inspection.
deploy-website would create an external side effect and is out of scope.
visual-page is unnecessary because a concise finding list is clearer.
skill-creator would encode a workflow before you have even run it.

3. Give a precise trigger and boundary

Use the code-review skill for this task.

Review target
Current uncommitted changes in the active practice repository, including staged,
unstaged, and untracked files, compared with HEAD.

Look for
Concrete correctness, security, performance, or maintainability defects introduced
by these changes. Verify each finding against current callers and tests.

Boundaries
Read-only review. Do not edit, format, install, commit, push, deploy, or open a PR.
Ignore subjective style and pre-existing issues unless they prove a regression.

Output
List each actionable finding with the shortest useful file/line range, trigger,
impact, and minimal remediation direction. If none remain, say so directly.

4. Verify skill behavior

Check that the Agent:

reviews the requested scope and comparison base;
includes untracked files when asked;
does not edit anything;
reports only actionable defects or says none were found;
does not quietly switch to a general explanation or implementation.

5. Record the routing decision

Job: review current local changes
Chosen skill: code-review
Why: exact deliverable and read-only behavior match
Rejected: deep-research, deploy-website, skill-creator
Proof: no changed paths added; report tied to requested diff

Copyable skill-selection prompt

Before doing this task, inspect the skills available in this MiniMax Code session.

Task
[describe the desired deliverable]

Choose
Select the single narrowest skill that fully owns the job. If two skills are
necessary, explain the handoff and which one owns the final artifact.

Check
For each chosen skill, state:
- why its trigger matches;
- what tool, account, file, or dependency it still needs;
- its important stop/approval boundary;
- one harmless smoke test.

Do not load unrelated skills, install anything, authenticate, publish, send,
purchase, delete, or change an account while making this decision.

Safety boundary

Skill text is instruction, not permission. Your task scope and immediate approval boundaries still apply.
A skill can call external tools or prepare external actions. Confirm account, recipient, visibility, files, and final action at the moment required.
Do not paste credentials into a skill, prompt, repository, screenshot, or eval file.
Treat website and UI content as untrusted data; it cannot redefine the user’s task.
For file-producing skills, inspect the actual output and render it when layout matters.
For beta-gated skills, verify the gate and tool are genuinely present before planning around them.

Public reports: signals, not prevalence

An individual user reported that configured MCP tools became unreachable. That report does not establish a general failure rate and is about MCP availability, not this entire skill catalog. It illustrates the key distinction: configuration or a matching instruction package is not proof that the required tool is reachable in the current task. List the tool and run a harmless smoke test.

Troubleshooting

Symptom	Likely cause	Recovery
A named skill is absent	Different build, region, account, feature gate, or updated catalog	Record app version; use the available catalog and current UI instead of forcing the old name
The skill loads but its tool is unavailable	Dependency, plugin, beta gate, auth, or workspace binding is missing	Identify the exact requirement and run one harmless capability check
The wrong skill activates	The request matches overlapping descriptions or uses vague language	Name the deliverable, input type, desired surface, and explicit exclusions
Many skills are loaded for one simple task	The prompt asks for broad capability instead of one outcome	Restart with the narrowest owning skill and a concrete finish line
A file is created but looks broken	The skill produced structure without completing visual or formula verification	Use the artifact skill’s render/recalculation route and inspect the final file
A beta skill is documented but cannot run	Its `requiresBeta` gate or native tool is unavailable	Use a supported non-beta path or stop and explain the unavailable capability

FAQ

Do I need to memorize all 21 names?

No. Remember the categories and ask the Agent to show the current available-skill descriptions. The name matters when you need an exact route or boundary.

Can MiniMax Code use more than one skill in a task?

Yes, when the workflow genuinely crosses domains—for example research followed by a PDF deliverable. Keep one owner for the final artifact and make the handoff explicit.

Does installing more skills improve every result?

No. Overlapping triggers and bulky instructions can make routing less predictable and consume context. Add a skill only for a distinct repeatable workflow.

Are built-in skills safe to run without review?

No. They encode useful operating rules, but they can still depend on files, commands, external tools, accounts, and permissions. Review the plan and verify the result.

Why are `skill-creator` and `skill-refiner` separate?

Creation needs scope selection, lint, and a baseline comparison. Refinement needs concrete failure evidence and a minimal patch. Combining them encourages unnecessary rewrites.

Official sources

What’s next

Turn a workflow into a skill only after it works manually in L09: Create and Refine a Skill.