DEV Community: SkillStack

One Skill Per Deck: Why I Stopped Bundling Presentation Templates

SkillStack — Tue, 27 Oct 2026 13:16:40 +0000

Most presentation template packs fail the same way: you install one giant bundle, then spend twenty minutes deleting eleven decks you will never use to find the one you actually want. I used to ship a single growing bundle. This week I split it apart, and the reason is embarrassingly simple: a template you have to hunt for is a template you will not use.

A deck skill should behave like a good tool, not a warehouse. One install, one deck, one job. When the agent opens the skill, it should know exactly which visual system it is working in — the colors, the grid, the slide order — without reading past fifteen other systems first. That is the whole argument, and it shows up in four places:

Install cost. A single-deck skill is a small folder: a SKILL.md, one .pptx, a detail file describing every editable slot, and a build script. Nothing else competes for the agent's attention.
Edit precision. With one deck, every slot in the detail file maps to exactly one shape on one slide. There is no "which deck's title slide did that edit land on" ambiguity, and a full 12-slide run can be verified slot by slot.
Style discipline. A bundle tempts you to reuse one deck's accent color in another. A standalone deck forces you to finish the palette: one paper, one ink, one signal color, and nothing borrowed.
Replacement cost. If a deck ages badly, you retire one skill. The other fifteen keep working untouched.

The four decks I split out this week make the point concretely, because they could not be more different from each other:

Night Observatory — a midnight annual review: deep ink, warm paper, amber signal, star-chart lines and orbit rings. Built for data that deserves a quiet room, not a dashboard.
Marrakech Souk — a quarterly market review: deep teal, sand paper, saffron and terracotta, arched cards and diamond tile strips. Loud in a warm way, never in a neon way.
Aizome Indigo — a collection retrospective: indigo papers, seigaiha wave lines, sashiko dashes, one vermilion seal block. Restraint as the whole personality.
Herbarium Botanical — a specimen-catalog deck: cream paper, moss ink, olive and terracotta, double-ruled specimen plates with Latin names. The kind of deck that makes a quarterly review feel archived, not just presented.

Each one is 12 slides, each slot addressable, each build verified end to end with a fictional brand so no real company gets used as demo filler. And each one installs alone: if you only need the indigo deck, you install the indigo deck, and your agent never learns the other three exist.

The practical test I now run before shipping any deck skill: hand the agent a fictional company, ask for all twelve slides, and check every slot. If a single slot comes back with placeholder text, the deck does not ship. A bundle makes that test twelve times harder to run honestly, because a failure in deck nine hides behind successes in decks one through eight. Splitting the bundle made the test cheap enough to actually run every time.

If you maintain a skill library of your own, try this: pick the one template your users actually open, ship it alone, and watch whether anyone misses the bundle. In my case, nobody did.

2,000 Skills for $15? Why Cheap Bundles Are a Trap

SkillStack — Tue, 20 Oct 2026 13:41:59 +0000

This week, three new shops started selling Claude skill bundles:

Skills Pack AI: 1,000+ files for $10, one-time payment, with an "85% OFF — TODAY ONLY" countdown timer on the page.
AI Avalanche: 2,000+ skills for $15, one-time payment, "$97 crossed out, 84% OFF — Today Only," plus a 7-day guarantee and a live Zoom onboarding call.
ToolGenX: 21 curated workflow packs, $9–$149 each on Gumroad, with an FAQ that opens with "This is wrong for half of you."

Two of these are playing the same game: win on price per file. The third is playing a different game entirely, and the difference is worth understanding — because "2,000 skills for $15" sounds like a steal until you do the math that actually matters.

Full disclosure: I run a small curated skill store (SkillStack). I have not bought these bundles, and I'm not going to pretend I know what's inside them. Everything below comes from their public pages. But you don't need to see inside to spot the trap, because the trap isn't in the files. It's in the unit of measurement.

The wrong denominator

$15 for 2,000 skills = $0.0075 per skill. That number is doing all the selling.

But nobody buys 2,000 skills to use 2,000 skills. You buy a bundle hoping 5–10 of them turn out to be genuinely useful. The real question is never "what does each file cost." It's "what does each usable skill cost" — usable meaning it works in your agent, on your machine, today, without an evening spent figuring out which files are current, which are broken, and which were written for a model two generations ago.

Be generous and say 50 of those 2,000 files earn their place. Your cost per usable skill is $0.30 — still cheap. Now add triage time: at 2 minutes per file to evaluate 2,000 files, that's 66 hours of your life. At any reasonable value of your time, the bundle just became the most expensive option on the page.

A single $9 skill that works out of the box — previewed, documented, tested against named agents — costs $9 and ten minutes. Do the full accounting and the "expensive" option wins. That's not a paradox. It's what happens when you measure the right denominator.

The countdown is the product

Both cheap-bundle pages run the same playbook: a slashed "original" price, a big percentage off, a timer insisting the deal ends today. That's pressure copy, not pricing information. The "discount" is the product being sold — the feeling of getting away with something.

There's nothing illegal about it, and the 7-day guarantees on these pages are real terms worth reading. But notice what a guarantee usually covers: a refund window, not a promise that "this skill works in my setup." Read the fine print before the timer runs out, not after.

Now look at the third shop. ToolGenX charges an order of magnitude more per item — and its FAQ actively tries to talk half its visitors out of buying. That's not a worse deal. That's a shop competing on a completely different axis: fit, not file count. I'm not affiliated with them; I'm pointing at them because they're the counterexample that proves the rule. When someone selling skills tells you not to buy, believe the business model, not the marketing.

To be fair: what the bundle shops get right

Honesty cuts both ways, so credit where it's due. AI Avalanche's page advertises a live Zoom onboarding call — a human helping you install. That's a genuine differentiator most $9 single-skill shops (including ours) don't offer, and for a less technical buyer it might be the most valuable line on the page. Both bundle shops also advertise lifetime updates and 7-day guarantees in plain language, which is more than you get from plenty of GitHub repos with a tip jar.

The problem was never that these are scams. The problem is the mismatch between what's being sold (a low price per file) and what determines whether you get value (how many files survive contact with your setup). A bundle with great support and a terrible hit rate can still be a bad buy for you — and a curated single skill with no onboarding call can be a great one. Judge the fit, not the fireworks.

The 10-minute test

You don't need my checklist memorized. Next time a bundle page tempts you, spend ten minutes before the timer "expires":

Pick three skills at random from the sales page (or the closest thing to a catalog it shows). For each, ask: could I describe what this does to a colleague in one sentence? If the page can't tell you, the bundle can't either.
Search for one skill name plus "not working" or "outdated." You're not looking for dirt — you're calibrating. A corpus of thousands will always have stale entries; you want to know whether anyone is pruning them.
Email support one question — "which agents and versions was this tested on?" The speed and specificity of the answer tells you more than the guarantee paragraph does.

If a shop passes all three, the per-file price is irrelevant — buy with confidence. If it fails the first one, no discount percentage can fix it.

The 3-point checklist (steal this)

Here's the checklist we put on our own buy-skills page — and yes, apply it to us too. Before you buy any bundle, ours included:

Can you see the finished output before paying? A preview image, a live demo, a concrete "what you get" list. If you're buying blind, you're not buying a skill. You're buying a lottery ticket.
Is each skill marked with which agents it was tested on? "Works with Claude Code" is a claim. A skill that names the agents and versions it was verified against is evidence. The difference matters the first time something silently fails at 11pm.
Does the refund policy cover "it just doesn't work for me"? A guarantee that only covers "we failed to deliver the files" is not the same as one that covers "the files don't work in my setup." Ask which one you're getting.

If a shop — any shop — answers all three clearly on the page, price per file stops mattering, because you're no longer gambling.

So what should you actually do?

If you want a raw corpus to mine for inspiration, the $10–$15 bundles are genuinely fine, and cheaper per file than anything we sell. We're not for that buyer, and we say so on our own page.

If you want skills you'll actually install this week, shop like a curator, not a collector: demand previews, demand tested-on labels, demand a refund policy that covers the real risk. The most expensive skill is the one you never get working.

We keep that checklist on our buy-skills page next to every listing — we'd rather you apply it to us and walk away than buy blind and churn. And if something there is worth buying: code ZD1UXZDI5FU8 takes 20% off until November 9, 2026.

Unslop, Explained: Which AI Writing Cleaner Fits You

SkillStack — Wed, 14 Oct 2026 13:23:20 +0000

If you've looked for a way to make AI-generated writing sound human lately, you've met the word unslop. It appears in Cursor skill lists, Claude Code plugin marketplaces, and writing-tool threads — and it sounds like a product. It isn't. It's a folk name, shared by at least seven open-source projects that disagree with each other about what "removing AI slop" even means.

This guide sorts them into three philosophies, gives each an honest verdict, and tells you which one fits your workflow. It ends with the cheapest intervention point of all: preventing slop instead of cleaning it.

Why "unslop" became a category

A year ago, "AI slop" was a complaint; now it's an editorial standard. Publications reject submissions that read machine-made, teams ship docs that customers actually read, and everyone has seen the same em-dash-heavy, bullet-pointed prose enough times to recognize it on sight. Unslop caught on as a name because it promises the opposite of that recognition — writing that passes the human test. The seven projects below disagree about how to get there, but they agree the problem is real.

1. The typography-swapping unslop: fast, deterministic, superficial

The most literal unslop is jere-mie/unslop: a tiny CLI written in Zig that strips what its README calls the "LLM accent." Em-dashes become hyphens, curly quotes become straight quotes, ellipses become three dots, non-breaking spaces become spaces. Zero dependencies, one static binary, recursive repo sanitizing in milliseconds, gitignored paths skipped by default, atomic file writes so a crash never leaves a file half-written.

A sibling lineage (packaged via uv, unslop --stdin --deterministic) adds one important idea: reproducibility. Same input, same output, every run — which is what you need when the step runs unattended in a pipeline. The cluxion skill wrapper frames it exactly right: a deterministic final pass before committing docs or publishing posts.

The honest verdict: this layer kills the glyph fingerprint, not the voice. A paragraph that read like AI still reads like AI — it just uses hyphens now. Install one as a pre-commit hook or CI step; don't mistake it for a writing-quality strategy.

2. The LLM copyeditors: slower, actually changes the voice

The second family admits that typography isn't the problem — the sentence shapes are. crypdick/unslop is a Claude Code plugin that detects the constellation of habits that make AI writing recognizable and rewrites the text the way a human copyeditor would: cutting filler, deflating importance, saying things straight. You say "unslop this" and get back prose that keeps your ideas but drops the AI voice.

mcnamee's standalone unslop skill does the same job with a design choice the others should copy: transparency. /unslop <text or file> returns the cleaned text and nothing else; ask "what changed?" and you get a before/after table with a reason per edit. No dependencies, no configuration, works on an airgapped machine.

kandulanikhilvarma's unslop-suite casts the widest net — prose, code, commit messages, decks — and can also audit without rewriting, scoring how machine-made a document reads.

The honest verdict: this is the only layer that changes how the writing sounds. The price is an extra model pass per document, variable output, and a review step you can't skip — an LLM sanding off slop can sand off your voice along with it. The before/after table is the best defense against that.

3. The empiricists: don't guess, measure

The cleverest idea in the family doesn't prescribe anything. Instead of a human guessing which phrases are overused, it generates 50+ domain-specific outputs from a model, runs statistical analysis on the recurring defaults, and writes a custom avoidance profile. Visual mode even screenshots HTML output to catch CSS and layout clichés. It ships with prebuilt profiles for writing and React design. (Find it via the avoid-slop directory, which catalogs this whole space.)

The philosophy behind it is the sharpest sentence in the anti-slop literature: telling a model to "write better" just creates a new flavor of slop; listing what not to do forces novelty rather than template substitution. That's worth remembering regardless of which tool you pick.

The honest verdict: highest setup cost, highest ceiling. Best for teams with a recurring output type — measure once, benefit forever.

The cheaper move: prevention beats cleanup

All three families above are post-hoc: the slop gets written, then scrubbed. The cheapest intervention point is upstream — a skill that stops the model from generating the tells in the first place.

That's the design behind stop-slop: roughly 30 banned phrases across 7 categories, 8 banned structural patterns, and a scoring rubric that triggers a revision pass when a draft scores below 35/50. Its best idea is "false agency" detection — AI gives inanimate things human verbs ("the data tells us," "the market rewards") to dodge naming actual actors, and naming the human fixes it. Em-dashes aren't "used sparingly" in this system. They're banned.

An honest note: prevention doesn't replace cleanup. A banned-phrase list can't fix pacing or structure — that's what the copyeditor layer is for. But it moves most of the work to the moment it's cheapest: generation time.

Which one should you install?

Commit messages, docs, changelogs in CI — the Zig CLI. Deterministic, instant, zero dependencies.
Blog posts and essays you care about — mcnamee's skill (the before/after table protects your voice), or the crypdick plugin if you live in Claude Code.
Recurring team output like landing pages or release notes — the empirical profiler. Measure once, benefit forever.
Everything, at the source — a prevention skill in your system prompt or Claude Project. One minute to install, and it makes the other layers' jobs smaller.

This is adapted from our longer guide, which ends with a concrete pick for frontend designers too: Unslop, Explained: Which AI Writing Cleaner Fits You.

The Bottleneck Moved: AI Coding Agents Write 30% More Code, but Teams Ship the Same

SkillStack — Tue, 13 Oct 2026 13:17:50 +0000

Most teams that adopted AI coding agents expected one thing: ship faster. A new Harvard working paper on 718 companies suggests they got the opposite of the metric that matters. Code volume rose about 30%, but delivered output barely moved — and time spent on code review jumped 49%.

The bottleneck didn't disappear. It moved downstream.

Why review became the choke point

Three forces collide here. First, generation is cheap and reviewing is not. An agent can produce in seconds what a human needs twenty minutes to verify. Second, agent-written code is often plausible — it reads well, passes a glance, and hides subtle issues in the exact places reviewers skim. Third, review capacity is fixed. You can't autoscale the senior engineer who understands the domain.

Anyone who's run a team through an agentic workflow has felt this: the queue of "ready for review" grows, PRs get bigger, and the careful review that used to happen before lunch now happens never.

What actually helps (beyond "write better prompts")

A few patterns are emerging from teams that are handling this well:

1. Make generation review-friendly. Ask the agent to keep diffs small and self-contained. A 40-line PR with a clear summary gets reviewed; a 900-line "feat: implement everything" PR gets rubber-stamped. The review burden is set at generation time, not review time.

2. Add a self-review pass before the human one. Have the agent review its own diff first — against the actual changed lines, not its memory of what it meant to write. Cheap, catches the embarrassing half of issues, and shortens the human pass that follows.

3. Require agent-written PR descriptions. Context is what makes review fast. "Why this approach" in three bullets beats any amount of code comments.

4. Measure review time, not just output. If your dashboard tracks lines generated but not time-to-merge, you're optimizing the part that's already fast.

The uncomfortable part

The paper's core finding is a management problem, not a tooling problem. Organizations bought generation speed and discovered their constraint was always verification — the one step that can't be delegated to the thing being verified. Until review gets the same engineering attention that generation got, that 30% more code is mostly inventory.

We dug into the paper's numbers, methodology, and the honest caveats in a full write-up (available in English and Chinese): https://skillstackhq.com/en/blog/ai-coding-agents-code-review-bottleneck

Claude Code Can Render Video: 5 Code-Rendered Video Skills Compared

SkillStack — Sun, 11 Oct 2026 16:09:20 +0000

Here's the thing most people get wrong about "AI video skills" for Claude Code: none of them generate footage with a video model. Every serious video skill in this space works the same way — your agent writes code (HTML, SVG, or Rust scenes), and a renderer turns that code into an MP4, frame by frame. The video is a build artifact, like a compiled binary. Change one line, re-render, get a new video.

That makes these skills inspectable, repeatable, and deterministic — the opposite of a diffusion model's slot machine. It also means your machine needs a renderer installed. This guide compares the five established players so you can pick the right one for the job.

The five approaches

Brag is the laziest way to get a launch video — and I mean that as praise. Point it at a project and the agent reads the actual code, then builds a ~20-second launch video: plan, composition brief, share copy, and the MP4. No live URL needed, no screenshots to take. It runs on the HyperFrames renderer under the hood (Node.js, FFmpeg). Best for: "I just shipped something, make me something to post."

HyperFrames is the framework Brag is built on, exposed directly. You (or your agent) compose scenes in HTML with data attributes for timing, and it renders by seeking each frame in headless Chrome — the same input always produces the same video. If your team thinks in HTML, CSS, and GSAP, this is the most expressive option: lyric videos, audiograms, promo reels. It's Apache 2.0 licensed, so commercial use is free.

fframes Video takes a different bet: Rust and SVG scenes rendered on the GPU. The payoff is speed and built-in checking — it ships an inspect command that validates frames without a full render, plus a half-resolution draft mode. The price is toolchain: you need Rust, a supported GPU, and FFmpeg libraries. Best for developers who want the fastest iteration loop and are comfortable outside the browser.

Lyric Music Video is the specialist: animated graphics synchronized to each sung word. If you have a finished song and a recurring visual idea, this is the one purpose-built tool in the list. Narrow, but exactly right for its niche.

Video Illustrator starts from the opposite end: your narration and your real assets, plus a chosen visual style, assembled into a short promo. Less "code art," more "slideshow with taste." Good when you already have material and need it packaged.

How to choose

Just shipped a project and want to post about it → Brag. Lowest effort, reads your repo.
Want full control in HTML/CSS/JS → HyperFrames. Most expressive, deterministic, free license.
Want the fastest renders and frame checking → fframes Video, if you have a GPU and don't mind Rust.
Have a finished song → Lyric Music Video.
Have narration and assets, need a promo → Video Illustrator.

Two honest caveats. First, none of these replace a video model: if you need photorealistic footage or complex character animation, you want a generator, not a renderer. Code-rendered video shines for motion graphics — text, shapes, charts, UI mockups — where precision beats realism. Second, output quality tracks your brief: "make a video" gets you a template; a one-sentence audience plus the single thing they should remember gets you something worth posting.

Don't want to install a toolchain?

All five skills above assume a local setup: Node or Rust, FFmpeg, sometimes a GPU. If you'd rather skip that, SkillStack Studio (https://skillstackhq.com/en/studio) runs the same HyperFrames pipeline hosted — pick a template, edit the text, render in the cloud, download the MP4. Same deterministic rendering, zero local dependencies. We also publish a free video-skill comparison and new animation templates regularly at https://skillstackhq.com.