DEV Community

Akshay Kumar BM
Akshay Kumar BM

Posted on

I Built an AI Skill That Writes LinkedIn Posts — And Then Used It to Write This Post

#ai #automation #showdev #socialmedia

I built an AI skill that writes LinkedIn posts. Then I used that skill to write the LinkedIn post about it.

That's either very meta or very efficient. Probably both.

What Even Is a Claude Code Skill?

A skill is a folder with a Markdown file inside it. That Markdown file teaches Claude exactly how to handle a specific task — your tone, your format, your rules, your quirks.

No Python. No backend. No complex config. Just structured instructions.

The folder goes in ~/.claude/skills/. You invoke it with a slash command. Claude reads the instructions and executes them.

That's it. The entire mechanism.

~/.claude/skills/
└── linkedin-post-creator/
    └── SKILL.md          ← this is the whole thing
Enter fullscreen mode Exit fullscreen mode

It sounds too simple until you actually build one and realise how much you've just automated.

How Skills Are Loaded (The Smart Part)

What makes this more than just a text file is Claude's progressive disclosure model:

  • Level 1 — always loaded: just the skill name and description (token-cheap, always visible)
  • Level 2 — loaded on trigger: the full SKILL.md instructions (only when you invoke it)
  • Level 3 — on demand: any scripts, references, or asset files bundled in the folder

Claude only loads what it needs, when it needs it. Your context window stays clean until you actually invoke the skill.

graph TD
    A[Session Start] --> B[Level 1: Load name + description only]
    B --> C{Skill invoked?}
    C -- Yes --> D[Level 2: Load SKILL.md instructions]
    D --> E{Scripts/references needed?}
    E -- Yes --> F[Level 3: Load on demand]
    E -- No --> G[Execute with SKILL.md only]
    C -- No --> H[Skills stay dormant — no context cost]
Enter fullscreen mode Exit fullscreen mode

📌 Pro Tip: Keep your SKILL.md under 500 lines. Move heavy reference docs into a references/ subfolder — Claude loads them only when the task needs them.

🔧 Step 1: Pick Something You Do Repeatedly

The best skill candidates are tasks that:

  • Happen frequently
  • Have a consistent structure
  • Require you to re-explain your preferences every time

For me, writing LinkedIn posts checked all three. Every session I was re-explaining my tone, my formatting style, my target audience, my hashtag strategy. Same setup work, every time.

That's a skill waiting to be built.

📝 Step 2: Write the SKILL.md

The SKILL.md has two parts: YAML frontmatter and a Markdown body.

---
name: linkedin-post-creator
description: "Creates LinkedIn posts in the author's personal voice and format.
  Use when asked to write a LinkedIn post, create content, or draft a professional
  update. Triggers: linkedin post, write post, social media content."
version: "1.0.0"
---

# LinkedIn Post Creator

You write LinkedIn posts in the author's personal voice.

## Voice and Tone
- Conversational but insightful
- First-person experience ("I built", "I tried", "Here's what happened")
- Hook in the first line — no slow warm-ups

## Format
- Short paragraphs, 2–3 lines max
- Emojis as visual anchors, not decoration
- Break ideas with --- dividers
- End with a question to drive comments
- 3–5 relevant hashtags at the bottom

## Workflow
1. Research the topic using live web data
2. Generate 3 complete post variations
3. Save all three to a timestamped file in the project
Enter fullscreen mode Exit fullscreen mode

The description field is the most important. It tells Claude what the skill does and when to use it. Write it in third person with explicit trigger keywords — Claude uses this to decide whether to auto-invoke the skill when your request matches.

🤖 Step 3: Invoke It

Once the skill is in ~/.claude/skills/, invoking it is just:

/linkedin-post-creator grafana alert automation
Enter fullscreen mode Exit fullscreen mode

Claude reads the SKILL.md, applies your voice and format, and generates content. With live web search hooked up (via Tavily MCP), it researches the topic first, then writes.

The output: three post variations, saved to a timestamped file automatically. What used to take 20–30 minutes of drafting and editing takes about 30 seconds of review and picking the best option.

💡 Step 4: Add Supporting Files (Optional but Powerful)

Skills can bundle more than just instructions:

~/.claude/skills/linkedin-post-creator/
├── SKILL.md                    ← instructions
├── references/
│   └── past-posts.md           ← examples of your best posts for calibration
├── examples/
│   └── sample-output.md        ← ideal output format
└── scripts/
    └── save-post.sh            ← auto-save to project folder
Enter fullscreen mode Exit fullscreen mode

The references/ and scripts/ directories are only loaded on demand (Level 3). They don't cost context tokens until needed.

📌 Pro Tip: Drop a few of your best past posts into references/past-posts.md. Claude will calibrate its output to match your actual style, not a generic version of it.

🚀 Step 5: Build Your First Skill With a Skill

Anthropic ships a skill-creator meta-skill in their official repo. It guides you through building other skills interactively — which is exactly as recursive as it sounds.

# 1. Download from the official repo
#    https://github.com/anthropics/skills/tree/main/skills/skill-creator

# 2. Drop it in your skills directory
cp -r skill-creator ~/.claude/skills/

# 3. Invoke it inside Claude Code
/skill-creator
Enter fullscreen mode Exit fullscreen mode

It asks what you want to automate, walks you through defining the instructions, and generates the SKILL.md for you. Then it can also eval and benchmark the skill to make sure it triggers correctly.

If you're not sure where to start, start here.

The Compounding Effect

Here's what surprised me most: skills don't just save time once. They compound.

After /linkedin-post-creator, I built:

  • /commit — structured git commit messages in my preferred format
  • /agent-builder — scaffolds new Claude agent configurations from a description
  • /breakdown — takes a product requirement and breaks it into epics and tasks
  • /tech-blog-generator — writes dev.to posts in my personal style (meta: this post was written with it)

Each took less than an hour. Each saves hours per month. And each one made the next faster to build — the pattern becomes automatic.

The mental model shifts: you stop thinking "how do I do this task" and start thinking "should I build a skill for this?"

graph LR
    A[Identify repetitive task] --> B[Write SKILL.md]
    B --> C[Invoke with /skill-name]
    C --> D[Iterate instructions]
    D --> E[Task automated]
    E --> F[Build next skill faster]
    F --> A
Enter fullscreen mode Exit fullscreen mode

What I Learned About Writing Good Skill Instructions

A few things that made the difference between skills that work and skills that don't:

Be explicit about WHEN to use it. Vague descriptions mean Claude either never auto-fires or fires at the wrong time. Add positive triggers ("use when writing a LinkedIn post") and negative boundaries ("do not use for email drafts").

Keep the body under 500 lines. Long skill files bloat Level 2 load. Move domain-specific docs to references/ and reference them by filename.

Add examples. An examples/ folder with ideal inputs and outputs calibrates Claude's output style better than any amount of written instruction.

Iterate. Your first skill will be too vague. Use it once, notice what Claude gets wrong, tighten the instructions, try again. Skills improve through iteration, not perfection.

Why This Feels Different From Other AI Tools

I've used AI tools that need APIs, pipelines, and orchestration frameworks. Powerful for complex systems — overkill for daily workflow tasks.

Skills are the right abstraction for the right problem:

  • Portable — a folder you copy anywhere
  • Version-controllable — just text, lives in git
  • No infrastructure — no deployment, no API keys beyond what Claude already has
  • Hot-reload — Claude Code 2.1 detects edits to ~/.claude/skills/ without restarting the session

The closest analogy is a specialist who already knows your preferences. You don't explain your style every time. You just assign the task.

✅ Zero infrastructure — a folder with a text file
✅ Persistent preferences — voice, format, and rules applied every time
✅ Composable — skills can reference other skills
✅ Compounding value — each skill makes the next faster to build
✅ Hot-reloadable — iterate without restarting your session

What Would You Automate First?

I'm curious what repetitive tasks you're still doing manually that a skill could handle. Writing? Code review? Documentation? Stand-up summaries?

Drop it in the comments — I'd love to brainstorm.

👋 Let's Connect

If you found this useful or want to compare skill setups, I'd love to connect.

🔗 Connect with me on LinkedIn
📧 Email: akshaykumarbedre.bm@gmail.com

Building AI-native developer workflows, one skill at a time. 🚀

Top comments (0)