How to Use Claude Code Skills in Cline

According to GitHub's Octoverse 2024 report, the number of developers building with generative AI on the platform surged by 178% year-over-year. This rapid expansion highlights how autonomous coding assistants like Cline are shifting from simple autocomplete extensions to agents that can edit, write, and execute code. However, managing this autonomy requires structured guidelines. While a general system instructions file like CLAUDE.md provides project-wide rules, it quickly bloats the context window during complex engineering tasks. This is where modular agent skills come in. By packaging domain-specific instructions into individual skills, you can expand your agent's capabilities on demand without wasting valuable tokens. In this guide, we will cover how to take modular skills, convert their structure into markdown, and load them into Cline rules configuration or workspace directories.

In the open standard for agentic systems, a skill is a directory containing a SKILL.md file. This format defines a standardized way to package instructions, checklists, and references for an AI agent. The SKILL.md file is composed of two primary sections: YAML frontmatter and a markdown body. The YAML frontmatter contains metadata that the agent reads to identify the skill and determine when it should be loaded. Specifically, it includes a name and a description field.

Here is a typical example of the claude code skill.md format representing a database validation task:

---
name: db-schema-validator
description: Use this skill when validating database migrations or editing Prisma schema files.
---

### Database Schema Validator Ensure all migration files use TypeScript.
Always run a dry-run migration before applying changes.
Check for foreign key constraints on new tables.

The body of the file contains the step-by-step instructions. The essential part of this format is progressive loading. Because the agent reads only the metadata first, the heavy instructions body is not loaded into the active context window until the user's request matches the description or a specific slash command is invoked. This keeps token usage low and improves response accuracy.

While Claude Code natively executes skills from its global or project-specific directory, Cline uses a different instructions architecture. Cline reads rules from a .clinerules file or a .clinerules/ directory in the project root, and also provides a rules configuration interface in its VS Code UI. To import Claude Code skills to Cline, you can adapt the SKILL.md structure into a format Cline understands.

Here is the step-by-step checklist to import and load a SKILL.md file in Cline:

1. Locate the skill folder containing the SKILL.md file you want to use.
2. Decide whether the instruction set should be always active or triggered on demand.
3. For an always-active rule, copy the markdown body of the SKILL.md file (excluding the YAML frontmatter) and append it to your project's .clinerules file in the workspace root.
4. For modular, on-demand rules, create a .clinerules/ directory in the root of your workspace, and save the skill as a standalone markdown file (e.g., .clinerules/db-schema.md). Cline automatically monitors this directory and merges the rules into its active context when relevant files or tasks are accessed.
5. Alternatively, open the Cline Rules UI panel in VS Code, click the rules edit button, and paste your markdown instructions directly into the custom rules configuration area.
6. Verify the installation by starting a new chat in Cline and asking a question related to the skill's description. The agent should acknowledge the specific constraints defined in your markdown file.

To learn more, check the Cline documentation on custom instructions.

In a collaborative development team, engineers often use different AI tools. Some might prefer Claude Code in their terminal, while others rely on Cline inside VS Code. Maintaining duplicate instruction sets across different developer machines is inefficient. To resolve this, teams can build a cross-agent skills setup where a single folder of markdown skills is shared across the entire team and their respective agents.

Local file sharing methods or simple Git repositories can work, but they introduce friction. If a developer refines an instruction block, every teammate must pull the changes manually. Similarly, storing these files in generic cloud storage like Google Drive or Dropbox lacks version control for text configurations and fails to provide native API integration for the autonomous agents themselves.

To address these challenges, teams can deploy their skills within a Fast.io shared workspace. Fast.io provides persistent workspace storage with granular permissions at the organization, workspace, folder, or file level. Because every file in a workspace keeps a full version history, any update to a skill file by one team member is tracked and auditable. This ensures that concurrent agent work remains transparent and prior versions can be restored easily. Rather than managing local copies on individual developer machines, the team's agents can pull the latest SKILL.md files directly from Fast.io using scoped API keys, creating a centralized, version-controlled source of truth.

Manage Cline skills in a shared team workspace

Share version-controlled skills, documentation, and consolidated MCP tools with your team. Starts with a 14-day free trial, credit card required.

Start 14-Day Trial

When using modular rules inside a .clinerules/ folder, you might encounter issues where Cline fails to apply the instructions. To troubleshoot skill loading, first ensure that the filenames and headings in your .clinerules/ folder are descriptive. Cline uses semantic search to scan these rules. If a task is about database migrations, but your rule file is named misc-instructions.md, the agent might not load it.

Another challenge is context bloat. While Cline can read hundreds of files, loading massive reference documentation directly into the chat prompt will slow down responses and increase API costs. Instead of pasting raw reference documents into your .clinerules files, you can use the Model Context Protocol (MCP) to let Cline query large files only when needed. Fast.io offers a consolidated MCP toolset. You can connect Cline to the Fast.io MCP server using Streamable HTTP at /mcp or legacy Server-Sent Events at /sse.

By combining Cline with the Fastio MCP server, the agent can search the workspace using semantic search to find relevant documentation pages. Additionally, teams can use Fastio Metadata Views to turn unstructured project logs, API specs, or task outputs into a structured database. By linking to the Fast.io Metadata Views guide, developers can see how these views use AI to extract fields from files in a workspace and populate a queryable spreadsheet. Cline can query these structured Metadata Views via the MCP server on demand, allowing the agent to verify database schemas or project requirements without bloat.

Modern software development is no longer a human-only endeavor. It is a collaborative process where developers, product managers, and autonomous agents work in the same files. To make this collaboration effective, teams need a shared environment that treats agents as first-class citizens. Using Fast.io Collaborative Notes, developers and agents can edit project plans, checklists, or deployment logs simultaneously, with live cursors showing the agent's active focus.

Once an agent like Cline finishes building a new feature or workspace setup, it can initiate an ownership transfer. This capability allows the agent to transfer the organization to a human developer via a claim link when the agent's work is complete. The human developer then takes full administrative control and starts a 14-day free trial (which requires a credit card) on a paid plan like Starter ($29/mo), Business ($99/mo), or Growth ($299/mo) to keep the project active. You can find detailed terms on the Fast.io pricing page. The agent can retain scoped admin access to run tasks, but the human remains the owner. This ensures that agent outputs are easily integrated into the team's daily operations.