Open-Source DeepSeek Skill Pack: Approaching Claude Opus with 29 Skills

Why Cheap Models Need a "Skill Pack"

According to a video reposted by a Bilibili creator, a developer who has long used DeepSeek^Ad found that DeepSeek V4.1 Flash can reach about 80% of Opus 5.5's level on everyday programming tasks—while being faster and priced on a completely different order of magnitude. But when first getting started, that ratio was only around 60%. The gap is almost never that the model isn't smart enough; it's a matter of "habits": writing code without a plan, claiming something is fixed without running tests, trying the same wrong approach four times in a row, and gradually losing sight of the goal in long tasks.

Files can't make a model smarter, but they can teach it to plan, check its work, and stop when stuck. This developer took apart several popular skill packs, dropped the parts tied to specific tools, rewrote them shorter and clearer, then added his own collaboration loops with DeepSeek and improvements targeting DeepSeek's weak default frontend design. The result is DeepSeek Stack: 29 skills, open-sourced under the MIT license, installable with a single command.

The Price Gap Determines the Approach

The original comparison: Opus 5.5 costs $4 per million input tokens and $20 per million output tokens; DeepSeek V4.1 Flash costs 15 cents per million input and 60 cents per million output during off-peak hours, with cached input at about one-thirtieth of a cent per million. Prices double during peak hours, but input is still over 13x cheaper than Opus and output over 16x cheaper.

This price gap changes the philosophy of token usage. With Opus, you carefully budget every token; with DeepSeek, spending more tokens for quality barely increases cost—run the same task three times instead of once, do another review in a fresh context, run the tests again. Many designs in the skill pack are built on the premise of "spending a few more cheap tokens to get results closer to an expensive model."

Installation and Runtime Environment

Run npx skills add ai-coking/deepseek-stack in your project directory to install. The tool lists the skills and asks which agents you use (Claude Code, Codex, Klein, OpenCode, etc.). Add the -g flag to install globally across all projects, or --skill to specify a single skill (e.g., --skill ds-verify-loop). All skills start with ds to avoid naming conflicts. They are essentially skill.md files, so in theory any agent that supports skills can use them.

The author runs this combination daily in PandaCode (his programming agent desktop app), connecting directly through DeepSeek's own ds8 harness: npm install -g @deepseek-ai/dsh, then paste the API Key in settings, select V4.1 Flash when creating a task, and set thinking effort to max. He emphasizes that this step cannot be skipped—turning off thinking drops test scores by nearly 30 points, more than any single skill in the pack.

KleinPass is a $9.99/month subscription from the Klein team that provides a collection of open models including DeepSeek V4.1 Flash, Kimi K3.1 Pro, GLM 5.3, and more, with generous quotas. In PandaCode, you can have the main DeepSeek task delegate some work to Klein workers, which is especially useful in review-type skills.

skills mechanism: Agent Skills, introduced by Anthropic in Claude Code, is essentially a directory containing SKILL.md. The file uses YAML frontmatter to declare the skill name, description, and trigger conditions, while the body contains instructions for the model. During a session, the model decides when to load a skill based on its description; once loaded, the instructions enter the context, effectively temporarily installing a set of behavioral guidelines for the agent. Skills contain no executable code—they constrain model behavior purely through natural language—so they are portable across agents: any host that can read SKILL.md and inject it into context can run them. This is why deepseek-stack works with different agents like Claude Code and Codex.

thinking effort: The budget level for a model's internal reasoning before generating an answer, typically divided into low/medium/high/max. The higher the level, the more thinking tokens the model consumes before producing final output, strengthening multi-step reasoning and self-checking—but latency and cost rise accordingly. For a cheap model like DeepSeek V4.1 Flash, setting this to maximum buys reasoning quality close to an expensive model at very low cost; conversely, turning off thinking makes the model skip reasoning and answer directly, with obvious degradation on programming tasks that require planning and verification.

Five Skill Groups: Core, Loops, Build, Deliver, Understand

The Core Three

/ds mode is the always-on working style—if you install only one skill, install this. It requires the model to restate the task in one line before acting, read code before changing it, make minimal changes, run real commands after every change, and never say "done" without showing output in the same message. One rule is critical: after the same fix fails twice, the model must stop and not attempt a third version of the same approach.

/ds principles is 21 engineering rules of thumb, each paired with a triggering scenario, such as "fix the root cause, not the symptom" and "delete code before adding code." It's rarely called directly but referenced by other skills. /ds help picks a skill for you based on your task description when you don't know which to use, and explains why.

harness: The runtime framework wrapping a large model, responsible for tool calls, file I/O, command execution, context management, and multi-turn loop scheduling. The model itself only generates tokens; what actually lets it read code, run tests, and open PRs is the harness. The ds8 harness mentioned here is DeepSeek's official runtime of this kind, through which PandaCode connects to the model. The harness's capabilities directly determine the skill pack's ceiling—requirements like "run real commands" and "screenshot comparison" in skills can only be fulfilled if the harness provides the corresponding tool interfaces.

Division of labor between plan loop and verify loop: The two are often confused. plan loop acts before starting work, producing a numbered plan with check items, self-reviewed and revised, solving "do the right thing"; verify loop acts after starting work, repeatedly fixing based on real command output until it passes, solving "do things right." The former prevents directional omissions; the latter prevents false completion claims. Chained together, they form the closed loop of "think clearly before changing, prove it after changing," the key structure behind the jump from 60% to 80%.

Loop Group: The Key to Closing the Gap

/ds plan loop targets changes involving multiple files: first write a numbered plan with verifiable check items for each step, then in a new round self-review whether the plan misses steps or makes risky assumptions, and only start after revising the plan, one step at a time. In the example, the model plans to add a dark mode toggle to a settings page, and during self-review realizes it forgot to handle the case where the saved value hasn't been read yet on first load—exactly the kind of issue DeepSeek tends to miss when diving straight in.

/ds verify loop is the author's most-used skill: change code, run real checks, read real errors, find root cause, fix, run again, and after at most five rounds must stop and report, pasting the final passing output—and must never weaken or skip tests just to make them pass. This alone blocks most "I fixed it" lies.

/ds unstick targets the model going in circles: when the same error recurs after two fixes, stop editing, write down the assumption shared by all failed fixes, and directly verify that assumption. If it holds, list three different approaches, pick one, and restart from a clean state. /ds context reset handles long tasks: the model maintains progress.md recording the goal, completed items and evidence, next steps, and key facts; when context grows long or starts repeating, switch to a new session that reads that file—being friendly to fresh context is one of DeepSeek's strengths. /ds ledger logs one line per decision during unattended long tasks (what was done, why, evidence), rereading before each step to avoid drifting from the goal.

/ds review loop hands changes to a reviewer in a fresh context, with the author iterating until both agree, up to four rounds. /ds jury is the enhanced version, collecting reviews from two or three different models and looping until consensus—this is where KleinPass shines: in PandaCode, DeepSeek leads and dispatches reviews as read-only tasks to Klein workers running Kimi K3.1 Pro and GLM 5.3. Different models make different mistakes, so they catch different problems, and at a $10 subscription plus cheap tokens, running it on every PR is painless.

/ds best of n is the author's favorite way to "spend cheap tokens": run the same task three to five times in parallel, pick the strongest as the base, then absorb the best fragments from the others. Running Opus five times is expensive; running DeepSeek five times is still cheaper than one Opus run. /ds swarm targets broad tasks, such as auditing every route of an API or checking every page of an app, then merging into a unified evidence-backed report.

Build Group and Design Skills

/ds sharpen handles vague requirements: restate what you actually want, and make the task deeper rather than bigger. /ds blueprint designs types, function signatures, and module layout first, filling in code only after confirming the shape. /ds tdd targets bugs: first write a test that fails for the right reason, then make the minimal change to pass it. /ds radius checks the impact of changes beyond their own diff—other callers, configs, persisted data, other services—and proves key safety facts with real runs rather than a paragraph claiming safety.

Design skills are considered one of the pack's strongest parts. /ds design requires the model to give a brief design direction before writing code: purpose, audience, tone, the one thing you want remembered; then set fonts, colors, spacing, and scrutinize the plan with "would I produce the same solution for any similar prompt," while maintaining a "cliché list" (purple-blue gradients, Inter as heading font, emoji as icons, centered hero with three identical cards). It takes screenshots at desktop and mobile sizes and fixes what it sees. In the example, for a landing page for a small coffee roaster, it produced warm paper texture, retro display fonts, and a layout built around the product line—far better than DeepSeek's default output. /ds design audit targets existing UIs: screenshot at two sizes, score hierarchy, typography, color, spacing, states, accessibility, and copy with evidence, then fix the top three to five issues and screenshot for comparison.

Deliver Group

This group relies on the GitHub CLI. /ds pr writes a short PR starting with the problem and including screenshots of both sides; /ds watchpr watches CI and review bots, fixing real issues and pushing until ready, merged, or blocked; /ds ship runs the whole flow from change to unattended merge, merging only after all checks pass and every finding is fixed or answered, never using admin bypass, and stopping to ask you before any irreversible action; /ds ready does the same but stops at PR ready, leaving the final merge to you—the author's most-used one.

/ds adopt takes over someone else's PR, branch, or agent thread, completing the original goal while preserving the original author's attribution; /ds revive updates old PRs, but first checks whether the idea still holds under the current code—sometimes the right answer is to close it; /ds pr comments ensures that comments posted on the agent's behalf are clearly marked as coming from the agent and don't leak anything that shouldn't be leaked.

Understand Group

/ds explain explains how a piece of code works and why it was built that way in plain language; /ds catch up summarizes what changed while you were away and every decision waiting on you, ideal after a long chain of workers has run; /ds lessons finds mistakes the agent repeatedly makes in your repo and turns each into a type, lint rule, or test so it can't happen again; /ds unslop strips AI-speak from docs, PR descriptions, and code comments—filler phrases and fake enthusiasm.

Daily Combinations and Limitations to Be Honest About

The author's daily usage is straightforward: ds mode always on; regular tasks start with ds plan loop, driven forward by ds verify loop, and when stuck, switch to ds unstick per mode's rules; run ds review loop before merging, ds jury with KleinPass workers for important changes, and finally ds ready to open the PR and get it green. For UI work, ds design replaces plan loop; for big tasks, use ds best of n or ds swarm, since tokens are cheap enough.

To be honest, this cannot turn DeepSeek V4.1 Flash into Opus 5.5. On thorny bug debugging in huge codebases and problems requiring extensive creative thinking, Opus still wins—sometimes by a lot. The 80% figure is the author's gut feel from his own daily work, not a benchmark, and should be treated with caution. Skills make every task consume more tokens, since there's more checking, reviewing, and sometimes more attempts, but at DeepSeek's prices that extra cost is small—better to pay for a model that actually runs tests than one that claims to have run them. Also, using DeepSeek means code is sent to its servers, so for private company projects, confirm whether that's allowed first; for big tasks, prefer off-peak hours when prices are halved.