Agent Skills for developer marketing: Picks and Shovels in your AI workflow

I wrote Picks and Shovels because I kept answering the same questions about developer marketing. How do you position a developer tool? What should a launch plan include? How do you run competitive analysis without becoming a copycat?

The book covers all of this. But a book is static. You read it, learn the frameworks, then apply them yourself. That's valuable, but it requires translation work. You need to take the abstract framework and apply it to your specific product.

Agent Skills change this equation.

I converted the core frameworks from Picks and Shovels into five Agent Skills that work with Claude Code and other compatible AI tools. Instead of reading about positioning frameworks and then building one, you can now ask Claude to build one for you using the exact methodology from the book.

This post explains what these skills do, how to install them, and how to use them effectively.

Why skills are the 2026 game-changer

This is where 2026 differs most dramatically from even a year ago. Everyone is shipping skills now. Google with Gemini. Supabase with their MCP integrations. The entire AI ecosystem is converging on the same idea: the future isn't just connecting AI to tools. It's teaching AI domain expertise.

Agent Skills are an open format for giving AI agents specialized knowledge. They're folders containing instructions, workflows, and references that agents load when relevant.

Think of them like this: Claude already knows a lot about marketing. But it doesn't know how you specifically approach developer marketing. Skills fill that gap. They give Claude access to your methodology, your frameworks, your way of doing things.

The format was developed by Anthropic and released as an open standard. It's now supported by Claude Code, Cursor, Gemini CLI, VS Code agents, and many other tools.

Skills work through progressive disclosure. The agent loads only the metadata (name and description) at startup. When you ask about something relevant, it loads the full instructions. This keeps context efficient while giving the agent access to deep knowledge when needed.

The transformation: before and after

Here's what makes skills different from just asking Claude for help.

Without the skill, I ask: "Help me create a competitive battlecard for our product vs Firebase."

Claude gives generic advice. Compare features. List pros and cons. Create a pricing table. It works, but it's superficial.

With the skill, Claude knows:

• Don't just list features, explain technical trade-offs and when each matters
• Structure objections in the customer's actual words, not sanitized marketing speak
• Include scenarios where the competitor genuinely wins, not just where you win
• Build trust by being honest about your weaknesses
• Frame "when to choose" guidance as helping customers make the right decision, not pushing your product
• Always link to proof (documentation, benchmarks, case studies) for technical claims

The skill transforms Claude from a helpful assistant into a competitive intelligence expert. It doesn't just follow instructions. It understands the domain. It anticipates problems. It suggests analysis I haven't thought of yet.

The Picks and Shovels skills

I created five skills based on the core frameworks from the book. These aren't thin instruction files. They're comprehensive domain knowledge documents that encode years of practice.

positioning (380 lines): Complete framework for market segmentation, ICP development, positioning statements, and messaging hierarchies using Aristotle's rhetorical principles (ethos, pathos, logos). Each pillar includes a mechanism layer (how you deliver on the claim), consequence framing (what happens if the customer does not act), and proof points. The skill also generates problem-framing variants, a differentiation summary, and runs four validation tests (duck test, category test, swap test, consequence test) before finalizing.

launch (400 lines): Launch tier classification, sine wave timing patterns, and complete checklists for pre-launch, launch day, and post-launch activities. Covers channel strategies for Product Hunt, Hacker News, Reddit, and developer communities. Based on frameworks from writing the perfect launch blog post and go-to-market planning.

content-strategy (470 lines): The Help First methodology, inside-out vs outside-in content distinction, funnel alignment, distribution strategies, and SEO targeting for technical audiences. Covers the 12 types of content that work for developers and content calendar planning.

competitive-analysis (490 lines): Comprehensive competitor identification covering all four types (direct, indirect, status quo, and build-it-yourself). Includes honest product teardown frameworks, battle card structure templates with consequence framing for each competitive alternative, and objection handling patterns for sales enablement.

gtm-strategy (385 lines): Go-to-market recommendations for developer products, from PLG to enterprise sales motions. Covers product-led growth, sales-led growth, open-source models, and hybrid approaches.

Each skill contains step-by-step workflows, templates, checklists, and common mistakes to avoid. They encode the methodology from the book in a format Claude can apply directly.

Installing the skills

Skills are just folders. You can install them anywhere Claude Code can access.

Option 1: Clone the repository

The skills are available in my dotfiles repo on GitHub. Clone it to your machine and copy the skills to your Claude Code skills directory:

git clone https://github.com/coolasspuppy/dotfiles.git ~/dotfiles
cp ~/dotfiles/claude/skills/*.md ~/.claude/skills/

This puts them in your Claude Code skills directory, making them available globally.

Option 2: Add to a project

If you want the skills available only within a specific project, copy them into that project:

cp ~/dotfiles/claude/skills/*.md your-project/.claude/skills/

Option 3: Copy individual skills

If you only want specific skills, copy just those files:

mkdir -p ~/.claude/skills
cp ~/dotfiles/claude/skills/positioning.md ~/.claude/skills/
cp ~/dotfiles/claude/skills/launch.md ~/.claude/skills/

After installation, restart Claude Code. The skills will appear in your available skills list.

Skills, slash commands, and prompts

Three tools. Different purposes. Understanding when to use each makes you faster.

Skills are domain knowledge. They teach Claude a methodology. The positioning skill doesn't do anything by itself. It waits until you ask Claude to help with positioning, then it shapes how Claude approaches the problem. Skills are passive. They're expertise on demand.

Slash commands are workflows. They're executable. Type /new-blog and Claude runs a multi-phase process: research, ideation, outlining, writing, editing. Slash commands are active. They do things.

Prompts are one-off requests. No framework, no workflow. Just a question and an answer. Fast and flexible, but you get generic responses unless you provide context yourself.

The power comes from combining them.

Example: Building a launch plan

Let me walk through combining skills and commands for a real scenario.

Say you're launching a new feature for your API platform. It's a significant addition that deserves attention, but it's not a completely new product. Here's how to approach it:

Step 1: Determine the launch tier

Start by asking Claude to help classify the launch:

I'm launching a new webhooks feature for our API platform. It lets
developers receive real-time notifications when events happen in
their application. Help me determine the appropriate launch tier
using the launch skill.

Claude will apply the tier framework from the skill:

• Tier 1 (major): New products, major versions, pivotal capabilities
• Tier 2 (significant): Important features, meaningful integrations
• Tier 3 (incremental): Minor improvements, bug fixes

For a webhooks feature, Claude will likely recommend Tier 2. It's important functionality that developers will care about, but not a whole new product.

Step 2: Set timing

The skill includes guidance on launch timing:

The webhooks feature will be ready by February 15. When should
we launch, and what timing considerations should we keep in mind?

Claude will apply the sine wave pattern and timing guidance:

• Avoid Mondays (people catching up) and Fridays (lost to the weekend)
• Target Tuesday, Wednesday, or Thursday
• Launch at 9-11 AM in your primary market's timezone
• Check for holiday conflicts across all major markets

For a February 15 readiness date, Claude might recommend launching Tuesday, February 18, at 10 AM Pacific.

Step 3: Build the timeline

Ask for the full launch timeline:

Create a launch timeline for the webhooks feature. Launch date
is February 18. What do we need to do in the weeks before,
the day of, and the weeks after?

Claude will generate a timeline using the skill's checklists:

Weeks before launch:

• Finalize positioning and messaging for webhooks
• Create launch brief document
• Set measurable goals (signups, documentation views)
• Align internal stakeholders

Week 1 before launch:

• Publish documentation
• Prepare demo environment
• Brief sales and support teams
• Seed with beta users for testimonials
• Schedule social media posts

Launch day:

• Publish blog post at 10 AM
• Update product with feature
• Send customer email
• Post on social channels
• Monitor and respond

Week after launch:

• Publish follow-up tutorial content
• Respond to all feedback
• Share early adoption stories
• Track conversion metrics

Step 4: Create the launch brief

Ask Claude to create the formal launch brief:

Create a launch brief document for the webhooks feature
using the template from the launch skill.

Claude generates a structured brief with overview, what you're launching, why it matters, target audience, key messages, success metrics, assets needed, and risks. The framework comes from the book. The specifics come from your context.

Step 5: Write the launch blog post

Now combine the skill with a slash command. The /new-blog command in my dotfiles repo runs a seven-phase process: market research, theme identification, content scoring, proposal generation, writing, revision, and distribution planning.

/new-blog

Topic: webhooks feature launch for API platform
Audience: backend developers building event-driven applications
Context: Use the launch brief we just created for messaging

Claude researches the space, identifies angles that will resonate, and writes a post that follows the launch messaging from your brief.

Step 6: Refine with content strategy

Finally, use another skill to evaluate and improve:

Use the content-strategy skill to evaluate this draft.
Does it follow the Help First methodology? Is it inside-out
or outside-in content? How should we distribute it?

Three tools in one workflow. The skill provides methodology. The command executes the work. Another skill refines the output.

Customizing the skills

The skills encode my methodology from the book. But methodologies evolve. You might want to modify them.

Adding your specifics

Create a project-level CLAUDE.md that references the skills and adds your context:

## Marketing skills
 
Use the picks-and-shovels skills for marketing work. When
applying them, keep these product specifics in mind:
 
- We target enterprise developers, not hobbyists
- Our sales cycle is typically 3-6 months
- We compete primarily against internal solutions (build vs buy)
- Our main differentiator is performance at scale

Claude will blend the skill workflows with your specific context.

Forking and modifying

Skills are just markdown files. Fork the repository and edit:

• Add sections relevant to your industry
• Remove sections that don't apply
• Modify checklists to match your process
• Add templates you use repeatedly

Keep the core structure intact so Claude can follow the workflow.

Summary

The skills and commands are available in my dotfiles repo on GitHub. Clone or fork it, then follow the installation instructions earlier in this post. The skills encode chapters on positioning, launches, content strategy, competitive analysis, and GTM strategy. I may add more as the format matures.

If you want the full methodology behind these skills, get the book. The skills work without it, but understanding the underlying thinking helps you guide Claude more effectively.

Developer marketing is complex work. These skills won't replace your judgment. But they can make Claude a better partner for applying proven frameworks to your specific challenges.