> ## Documentation Index > Fetch the complete documentation index at: https://deepline.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Claude Code Skills > 4 open-source skills turn Claude Code into a GTM automation engine. Use it to understand the tradeoffs, cost model, and operating boundaries before you build. Deepline ships 4 open-source skills that give Claude Code structured GTM knowledge. Instead of prompting from scratch every time, you install a skill once and invoke it as a slash command. The skill tells Claude Code exactly which providers to call, in what order, with validated parameters — so you get reliable results on the first run instead of the fifth. Skills are not required. The Deepline CLI works without them. But if you run the same enrichment workflows repeatedly — building TAM lists, running email waterfalls, detecting job changes — skills eliminate the setup time and make every run consistent. | Attribute | Value | | ------------------------ | ---------------------------------------------- | | Skills available | 4 user-facing skills | | Install command | `/skill install deepline` (inside Claude Code) | | Recipes in deepline-gtm | 7 step-by-step playbooks | | Agent compatibility | Claude Code, Codex, Cursor | | Source | Open-source on GitHub | | Required to use Deepline | No — CLI works standalone | *** ## What skills mean for your GTM workflow Skills solve a specific problem: AI agents are inconsistent. The same prompt can produce different provider choices, parameter formats, and execution orders on every run. Skills fix that by encoding proven workflows into reusable documents that the agent reads before executing. * **Natural language GTM automation.** Type `/deepline-gtm` followed by what you want in plain English — e.g. `/deepline-gtm find work emails for these 200 contacts` — and the skill handles provider selection, waterfall ordering, validation, and output formatting. You describe the outcome; the skill handles the how. * **Repeatable playbooks.** TAM building, waterfall enrichment, job change detection, portfolio prospecting — these follow the same steps every time. Skills encode those steps as slash commands so every run follows the same proven path, whether you execute it or a teammate does. * **Team standardization.** Skills are files. Share them via Git, and everyone uses the same provider priorities, cost thresholds, and approval gates. No more "it works differently when I run it." * **Not required.** Every Deepline operation works through `deepline tools execute` and `deepline enrich` without any skill installed. Skills add a knowledge layer that makes the agent smarter about sequencing, provider selection, and error handling — but they are optional. *** ## Available skills Deepline ships 4 user-facing skills. Each one is a collection of markdown documents that Claude Code reads before executing your request. ### deepline-gtm The primary skill. Covers the full GTM workflow from prospecting through enrichment to outreach. This is the skill most teams install first and use daily. **What it handles:** * Finding companies and contacts (Apollo, Crustdata, PDL, and more) * Enriching and researching (waterfalls, signal extraction, verification) * Writing outreach (personalization, qualification, email drafting) * Provider-specific playbooks with validated parameters and known pitfalls * 7 recipes for common GTM tasks (detailed below) **Includes sub-documents for:** * Finding companies and contacts — provider selection, role-based search, parallel execution * Enriching and researching — waterfall patterns, email/phone/LinkedIn enrichment, play tools * Writing outreach — qualification frameworks, personalization, email copy * Actor contracts — Apify actor execution patterns * Provider playbooks — per-provider quirks, cost notes, fallback behavior ### clay-to-deepline Migrates Clay table configurations into local Deepline scripts. Use this when you have a Clay table JSON export, a Clay API response, or a Clay workbook URL and want to replicate the workflow without Clay. **What it handles:** * Converting Clay AI action columns (Claygent, use-ai, chat-gpt-schema-mapper) into `deepline enrich` with `call_ai`, `exa_search`, and `run_javascript` * Replicating Clay record fetching with Deepline providers * Producing standalone bash + Deepline scripts that run locally **Useful when:** * "Convert my Clay table into a Deepline script" * "I have a Clay JSON export, make it work with Deepline" * "Replicate this Clay workflow without the platform fee" ### deepline-feedback Sends structured feedback or bug reports to the Deepline team. Automatically captures your session transcript, environment info, and reproduction steps. **What it handles:** * Collecting feedback text from the user * Packaging session context (transcript, environment, CLI version) * Submitting to the Deepline team **Useful when:** * "Something broke during my enrichment run" * "I want to request a new provider integration" * "This waterfall is returning bad results, can you look into it?" ### niche-signal-discovery Discovers differential signals between Closed Won and Closed Lost accounts. Extracts website content, job listings, and tech stack data, then computes lift scores to identify what distinguishes buyers from non-buyers. **What it handles:** * Multi-page website content extraction for won vs lost accounts * Job listing analysis for hiring signals * Laplace-smoothed lift scoring for signal ranking * Building account scoring models and prospecting criteria from real data **Useful when:** * "What signals differentiate my best customers from lost deals?" * "Build me an ICP scoring model from my CRM data" * "Find niche signals I can use to prioritize accounts" *** ## deepline-gtm recipes The deepline-gtm includes 7 recipes — step-by-step playbooks for specific GTM tasks. Each recipe tells Claude Code exactly what to read, which providers to use, and in what order. ### build-tam Build a Total Addressable Market list by sourcing accounts and contacts from providers like Apollo, Crustdata, and PDL. Start with company discovery criteria (industry, headcount, location, funding), find matching accounts, then find contacts at each one. ``` /deepline-gtm Build a TAM list of Series B+ fintech companies in the US with 50-500 employees ``` ### portfolio-prospecting Find companies backed by a specific investor or accelerator (YC, a16z, Sequoia), then find contacts and build personalized outbound. The recipe's core insight: VC portfolio data is public. It fetches portfolio pages directly instead of wasting credits on provider searches. ``` /deepline-gtm Find all YC W24 companies and get me the CEO email for each one ``` ### waterfall-enrichment Run multiple enrichment providers in sequence, stopping at the first valid result. Maximizes coverage while minimizing cost — you only pay for the provider that finds the answer. Works for email, phone, LinkedIn, and company data. ``` /deepline-gtm Enrich my CSV with emails using the waterfall pattern ``` ### job-change-detector Detect CRM contacts who changed jobs in the last 6 months, find their new work emails, update the CRM, and add them to re-engagement campaigns. Integrates with HubSpot via MCP tools. ``` /deepline-gtm Find contacts in HubSpot who changed jobs and update their records ``` ### contact-to-email Find and verify email addresses from whatever starting data you have: name + company, LinkedIn URL, or name + domain. Routes to the right play tool based on your input columns. ``` /deepline-gtm I have names and companies in this CSV, find their work emails ``` ### get-leads-at-company From a company name, find the right GTM contacts (by role/title), enrich their contact info, and optionally draft personalized outreach. Chains company lookup, contact discovery, email waterfall, and outreach generation. ``` /deepline-gtm Get me the VP of Sales at each company in accounts.csv and draft a cold email ``` ### linkedin-url-lookup Resolve LinkedIn profile URLs from name + company with strict identity validation to avoid false positives. Uses multiple providers with cross-validation to ensure the profile matches the right person. ``` /deepline-gtm Find LinkedIn URLs for the contacts in my CSV and verify they match ``` *** ## How to install ### Inside Claude Code Run the slash command: ``` /skill install deepline ``` This installs all 4 user-facing skills. After installation, skills are available as slash commands in your Claude Code session. ### Verify installation After installing, confirm the skills loaded: ```bash theme={null} ls ~/.claude/skills/ ``` You should see directories for `deepline-gtm`, `clay-to-deepline`, `deepline-feedback`, and `niche-signal-discovery`. ### Using with Codex and Cursor Skills also work with Codex and Cursor. The hosted installer also targets Gemini CLI and Antigravity. For the full multi-agent setup, including Hermes CLI usage, see [Coding Agents](/docs/sdk-v2/coding-agents). ### Updating skills Skills are versioned with the Deepline CLI. When you update the CLI, skills update too: ```bash theme={null} deepline update ``` `deepline update` refreshes the CLI and replaces the installed Deepline skills when their required version changes. To repair an unhealthy installation: ```bash theme={null} deepline doctor --json ``` *** ## FAQ No. Every Deepline operation is available through `deepline tools execute` and `deepline enrich` without any skill installed. Skills add a knowledge layer that makes your AI agent smarter about provider selection, sequencing, and error handling. They make things faster and more consistent, but they are not required. The CLI is the execution layer — it calls providers, runs waterfalls, processes CSVs. Skills are the knowledge layer — they tell your AI agent which CLI commands to run, in what order, with what parameters. Skills do not replace the CLI; they make it easier for agents to use the CLI correctly. Yes. Skills are open-source markdown files. Fork them, edit them, add your own provider preferences or approval gates, and share them with your team via Git. The skill files live in `~/.claude/skills/` after installation. No. Skills themselves are free. They are documentation files that guide your agent. The underlying provider calls (email lookups, enrichments, scraping) cost credits as usual, but the skill layer adds zero cost. Plays and recipes in the docs are reference material for humans. Skills are the same knowledge packaged for AI agents — structured so Claude Code, Codex, or Cursor can read them and execute the workflow automatically. The content overlaps, but skills include execution-specific details like parameter schemas, provider fallback orders, and error handling that agents need. Yes. A skill is a directory with a `SKILL.md` entrypoint and optional sub-documents. Follow the same structure as the built-in skills: a frontmatter block with name and description, then markdown content with execution steps. See the Deepline GitHub repo for the full skill specification. Start with `deepline-gtm`. It covers the full GTM workflow and includes 7 recipes for the most common tasks. The other skills are specialized — install them when you need Clay migration, feedback reporting, or ICP signal analysis. *** ## What's next Install Deepline and find your first email in 60 seconds. Commands, endpoints, payloads, and waterfall syntax. Human-readable workflow guides for common GTM tasks. BYOK is free. Managed credits start at \$0.10 each, with discounts from 1,000+ credits.