Hi there, I’m Leo from Firecrawl. In this post, I’ll show you how I built a Claude Skills generator that automatically creates complete skill documentation from any URL.

Claude skills are changing how people use AI in their day-to-day. They’re markdown files that extend Claude with new capabilities, trigger automatically based on context, and work across every project once you set them up.

Skills are streamlining workflows everywhere.

Need web scraping? Add a skill.

Want PDF processing? Add a skill.

Need API integrations? Add a skill.

Instead of copying and pasting the same instructions over and over, you define the behavior once and it works the same every time.

But here’s the thing: even though skills make your work easier, creating them manually is still tedious. You have to dig through documentation, extract the right information, understand the structure, format everything correctly, and make sure you don’t miss anything important.

At Firecrawl, we were creating a lot of Claude skills. It was taking hours for something that felt like it should be automated. So we built an internal tool: a Claude Code Skills Generator using Firecrawl’s /agent endpoint.

Give it a URL, and it generates complete Claude skill files with proper formatting, structure, and documentation. Everything you need, ready to use.

You’d start by accessing the URL, then either crawl or map everything. Mapping is probably better because you’d give the mapping context to the language model without crawling through things you might not need.

Once you have mapped everything, you’d have an array full of URLs. You’d send these URLs to an AI agent. After the agent reads them, it would process and understand what each URL is about. This URL is about an endpoint. This URL is about SDKs. This is for integrations.

If it doesn’t care about any of those, it keeps searching until it finds all the endpoints it should be finding. If none of those might be related to what you asked for, it will keep searching until it actually finds what you need.

Now that it has the URL, it goes inside, scrapes everything, brings it back to the context window, figures out what the structured output should look like, structures the data, and outputs it.

And all this would have to be created by us.

Even if you use a tool like n8n with a visual interface, you’d still need to do a lot of work.

You’d start with a chat message trigger, then send that message to an AI agent. After that, you’d have to give that agent access to different tools that can manage all this. Firecrawl provides these tools, so you could use them.

You’d select the Firecrawl tool and choose scraping. Make the URL input field dynamic so the AI could assign that value. Then you’d need to add another tool for mapping and search. Make those inputs dynamic too.

Then you’d add the crawling tool and make that input field dynamic as well. There are many more tools you could add, but just as an example, you’d already have three.

Now you need the AI agent to output in a specific format. So you’d toggle structured output and add the structured output parser. Here’s where you define the schema that it might output for us.

And to actually make it produce dynamic outputs based on the data it’s given, you’d have to add a lot of system prompting. Once you did all this, you’d have maybe 5% of what the actual Firecrawl agent endpoint can do.

This is where Firecrawl’s /agent endpoint comes in. Instead of building and maintaining all that complexity yourself, you can:

1. Send a prompt describing what you want
2. Include a schema for the output format
3. Make one API call
4. Get back structured, accurate results

For my Claude Skills generator, I send a prompt that describes the guidelines for Claude to produce a Claude skill. Then I define a schema that tells the agent what fields it needs to fill in.

After that, it’s just a single POST request to Firecrawl’s agent endpoint to do all the work.

The agent handles everything else: mapping sites, searching for the right pages, extracting content, and formatting it according to your schema.

The generated files are detailed and precise. The skill markdown file follows the exact structure needed for Claude skills:

• Name and description at the top
• A decision tree showing when to use the skill
• References to all related files
• Proper formatting throughout

Everything is structured correctly and ready to use. Look at the size of these files and the precision. It’s exactly what you need without any manual work.

We’ve recently added two new models to the agent endpoint:

Spark 1 Mini: This is the default model if you don’t specify one. It’s 60% cheaper and great for most use cases.

Spark 1 Pro: Use this when you need better accuracy for complex searches and critical extractions.

To use Spark 1 Pro, just add this to your request body:

{
  "model": "spark-1-pro"
}

Or if you want to explicitly use Mini:

{
  "model": "spark-1-mini"
}

That’s it. The agent handles everything else.

If you want to see the complete implementation of this Claude Skills generator, check out the GitHub repository GitHub repository. You’ll see exactly how simple it is to use Firecrawl’s agent endpoint for complex automation tasks like this.