---
title: "How I Write my Cursor Skills for Marketing Work"
date: 2026-08-06
author: "Matt Cromwell"
featured_image: "https://rootsandfruit.com/wp-content/uploads/2026/08/rf-featured-write-cursor-skills-2400x1260-1.png"
categories:
  - name: "AI & Workflows"
    url: "/ai-workflows.md"
---

# How I Write my Cursor Skills for Marketing Work

## Key Takeaways

1. Agents are better at writing skills than humans, so I wrote a skill to write all my skills
2. It’s got three tiers: A, B, and C, each aligns with the degree of complexity the skill needs
3. You can download and install my write-a-skill for free today



![How I Write my Cursor Skills for Marketing Work](https://rootsandfruit.com/wp-content/themes/rf/assets/articles/write-cursor-skills-1680.png)I use Cursor every day for a wide array of marketing-related tasks. Though it’s an IDE, made for developers in mind, I’ve found it ideal for storing local context and producing high-value reports and insights.

One of the things that took me really long to figure out though was how to leverage skills well. There are a million agent skills out there, and you can just download them into your .skills folder and run; but that doesn’t mean that they’ll actually produce high-quality work.

After a lot of trial and error and seeing lackluster results and feeling like I spend more time on “tooling” than on producing work; I’ve finally found what I believe to be a more reliable way to write skills. And the irony is, I write my skills now… with a skill.

**TLDR;** skip to the bottom if you just want to download my write-a-skill skill now. If you want to know the nitty-gritty, here’s the details:



## The anatomy of an agent skill and why it matters

An agent skill is just a folder with a `SKILL.md` file inside. Up top is what’s called “frontmatter”. Think of that like “post meta” in WordPress. It’s typically just the skill `name` and a `description`. The `name` field is a shorthand way of invoking this skill directly. You can do that in Cursor with a slash command, like `write-a-skill`. The description is what Cursor reads to decide whether the skill is even worth opening or leveraging.

If you’ve read the other pieces in this series, you know that I find that agents very easily ignore skills. One of the biggest reason is because either the name or the description or both are not written in a way that makes the purpose of the skill more obvious or useful to the agent for the kinds of tasks you are asking it for.

So combine a clear, focused name and description with what I call my [3-factor invocation](https://rootsandfruit.com/term/3-factor-invocation/)3-factor invocation3-factor invocation is a method for invoking an agent skill in your Cursor or Claude chat session to ensure the skill gets leveraged by the agent immediately instead of inferred or completely ignored.  
[Learn more](https://rootsandfruit.com/term/3-factor-invocation/) method, and now you’re cooking:

01

### Invoke

At-mention your skill directly in your prompt. This ensures the Agent goes there first.

02

### Goal

State your goal clearly and make sure it’s aligned with the purpose of the skill itself.

03

### Alignment

Ensure your prompt goal is aligned with the goal of the skill. Without alignment the Agent infers.



After that is the core instructions you want the agent to follow for this particular skill.

Sometimes you add a `REFERENCE.md` or `EXAMPLES.md` alongside it once the detail gets long, but those are optional, not the point. [Cursor’s own docs](https://cursor.com/docs/skills) cover the folder-and-frontmatter tour properly, so I won’t repeat it here.

What actually matters is what goes inside that description and those instructions, because that part is where most tutorials stop and where most of the flakiness actually lives.

## What my write-a-skill skill does

As I experimented over and over with skills, what I eventually realized is that I, as a human, am not best suited to actually write a skill. Skills are intended for agent-consumption, not human consumption. If I get all poetic and hand-wavy the agent won’t know exactly what to do. Ironically, agents are really great at writing instructions for other agents to follow. Thus, a skill for writing skills.

I use `write-a-skill` to write all my skills with a prompt specifically aimed at a narrowly defined task that I do all the time that I want an agent to help me with. The skill goes through a short few steps to do what it does: what’s the job of the skill in one sentence, does it branch into different modes, what comes out the other end, who consumes that output, where does the logic get fragile, and what data does it actually need. Answering those six items honestly and I already know how much skill I’m building before I write a single line. Most often my prompt to the agent is direct and clear enough that I don’t have to answer all of those myself, the agent can infer them with enough context; but that’s typically because I’m asking it to write a skill in the middle of a long thread of other work I already did with the agent, so the whole thread and outcomes of that work is the context that informs the skill as well.

A lot of this thinking started when I stumbled on Matt Pocock’s [write-a-skill](https://www.skills.sh/mattpocock/skills/write-a-skill), and Matt Batchelder’s [skillpatterns.ai](https://skillpatterns.ai) shaped a lot of how I think about reusable skill patterns too. Credit where it’s due. Neither of them invented the Agent Skills format, and neither did I, but both influenced my skill heavily.

In my version there are three tiers, and the tier tells you as much about the job as it does about the skill:

TierAnatomyWhen it’s the best pathA – LeanOne SKILL.mdA human can read the prose and tell if the output is right. This is what 98% of “marketing skills” out there do.B – DisclosedSKILL.md + REFERENCE.md + EXAMPLES.mdThe detail got long enough that stuffing it into one file makes the skill unreadable. Good place for “use the DataForSEO MCP for this” or a bad-result example.C – Regression-gatedTier B + fixtures + a verify scriptAnother skill downstream consumes structured output from this one, or the task is deterministic enough that I want a script checking it, not another AI opinion.

You can see all three tiers doing real work in [robots-txt-audit](https://github.com/Roots-and-Fruit/skills/tree/master/marketing/skills/robots-txt-audit), the skill I [wrote about a few weeks back](https://rootsandfruit.com/articles/robots-txt-skill/). That one earned its way to Tier C because it hands a JSON matrix off to other skills in the chain. A skill that just rewrites a paragraph in my voice never needs that much scaffolding. It stays Tier A, and that’s fine.

## How I test and improve my skills

After I write a skill, I spend the next 30 minutes testing it. Here’s a habit that felt a little silly the first time I did it and now feels obvious. I keep two agents open side by side. One agent runs the skill on a real job. The second agent’s only job is to read what the first one produced and tell me where it hallucinated, inferred, or skipped a step the skill actually asked for. Or where it just needs more fine-tuning to get closer to the outcome we’re intending. Again, agents are really good at reviewing the work of other agents.

That second agent catches things I’d never notice reading my own skill file, because I already know what I meant when I wrote it. It doesn’t. It just reads the instructions against the output and tells me if they match.

For Tier C skills, I don’t lean on a second agent alone. Those skills ship with an actual verify script, so the check is deterministic instead of another AI opinion stacked on top of the first. That’s the whole point of earning Tier C.

> Once a skill’s output needs to be predictable, I’d rather trust a script than trust two agents agreeing with each other.

## Try out my write-a-skill skill

`write-a-skill` lives in the [Roots & Fruit skills repo](https://github.com/Roots-and-Fruit/skills/tree/master/utilities/write-a-skill), under `utilities`. Clone it, or point Cursor at the GitHub URL and ask it to pull the skill in for you. Either way works.

![](/wp-content/themes/rf/assets/articles/skills-repo.png)### [skills](https://github.com/Roots-and-Fruit/skills)

By Roots-and-Fruit

Cursor agent skills for Roots & Fruit marketing and product development

**Install locally:**





```
npx skills add Roots-and-Fruit/skills -g -y
```

Bash

Pick one marketing job you already do by hand. Answer the six intake questions honestly, even the ones that feel obvious. @-mention write-a-skill in your prompt and tell it the job, the same way I invoke every skill in the library: mention it, state the goal, keep the goal and the skill aimed at the same thing.





```
Use @write-a-skill to turn this job into a skill:
Job: [the one thing you do by hand, in one sentence]
Output: [prose only, or prose + structured data]
Ask me once if any intake answer is missing, don't guess.
```



Most people treat skills like just a file to download instead of something they maintain and should expect the right things from. Write one, watch it drift after a few real runs, and you’ll understand why I stopped hoping the agent would just figure it out and started writing the skill that writes my skills.