Claude can review data, check code, write reports, and prepare presentations, but teams still end up repeating the same structure, validation rules, company standards, and final-check instructions in every conversation. That repetition wastes time and often leads to inconsistent results.<\/p>\n
Custom Skills solve this by packaging reusable instructions, workflows, templates, scripts, examples, and reference files that Claude automatically loads for matching tasks. In this article, we\u2019ll explore how Claude Skills works, examine the configuration options, and build a practical CSV auditing skill step by step.<\/p>\n
What Are Custom Skills in Claude?<\/h2>\n
A skill is a directory. It contains instructions for Claude, and optionally extra resources that help Claude complete a specific task.<\/p>\n
Every skill needs one file:<\/p>\n
SKILL.md<\/strong><\/p>\n This file defines what the skill does, when it should be used, and the steps Claude should follow. It can define the output format and point to scripts, templates, examples, or reference files.<\/p>\n A more advanced skill may look like this:<\/p>\n Only SKILL.md<\/strong> <\/strong>is required. Everything else is optional.<\/p>\n Skills follow the Agent Skills open standard<\/strong> agentskills.io<\/a>, which means the portable core: name<\/strong>, <\/strong>description<\/strong>, and plain Markdown works across Claude apps, Claude Code, the Claude Agent SDK, and the Claude Developer Platform. Individual products then extend the standard with their own features, and this is where most confusion comes from. We will map those differences carefully later in the article.<\/p>\n If you have used Claude Code before, you probably have files sitting in .claude\/commands\/<\/strong>.<\/strong> Custom commands have been merged into skills. A file at .claude\/commands\/deploy.md<\/strong> <\/strong>and a skill at .claude\/skills\/deploy\/SKILL.md<\/strong> both create \/deploy<\/strong> and behave the same way.<\/p>\n Your existing command files keep working. Skills simply add optional capabilities on top: a directory for supporting files, frontmatter that controls whether you or Claude invokes them, and automatic loading when the task is relevant.<\/p>\n If a skill and a command share the same name, the skill takes precedence.<\/p>\n No. A basic custom skill needs nothing but Markdown.<\/p>\n For example:<\/p>\n That is already complete, working skill.<\/p>\n Code becomes useful when your skill needs to analyse data, process files, validate outputs, generate visualisations, transform structured information, call command-line utilities, perform deterministic calculations, create or modify documents, or automate development workflows.<\/p>\n A simple rule:<\/p>\n Start with Markdown. Add code only when instructions alone cannot produce reliable execution.<\/p>\n Skills use progressive disclosure<\/strong>. Instead of loading every skill and every file into the context window, Claude loads information in stages.<\/p>\n At startup, Claude reads only the metadata from each available skill essentially the name<\/strong> <\/strong>and <\/strong>description<\/strong>:<\/strong><\/p>\n Claude uses the description to decide whether the skill matches your request.<\/p>\n This should activate the skill:<\/p>\n Can you check this customer dataset for <\/em>data quality<\/em> problems?<\/em><\/p>\n This should not:<\/p>\n Write an email announcing the product launch.<\/em><\/p>\n The description is the single most important field in the file, because it is the only thing Claude sees before deciding whether to load anything else.<\/p>\n Once Claude decides the skill is relevant, it loads the Markdown body of SKILL.md<\/strong>. This is where the workflow, rules, constraints, validation checks, and output format live.<\/p>\n Claude then reads scripts, examples, references, and templates only as needed:<\/p>\n Reference files and data cost no context tokens until they are actually read. Scripts cost even less: they execute through bash, and only their output consumes context.<\/p>\n When a skill is invoked in Claude Code, the rendered SKILL.md<\/strong> enters the conversation as a single message and stays there for the rest of the session<\/strong>. Claude Code does not re-read the file on later turns.<\/p>\n Two practical implications:<\/p>\n During auto-compaction, Claude Code re-attaches the most recent invocation of each skill after the summary, keeping the first 5,000 tokens of each within a combined 25,000-token budget. The skills you invoked long ago can be dropped entirely. If a skill seems to stop influencing behaviour after a long session, re-invoke it.<\/p>\n A typical skill directory:<\/p>\n SKILL.md<\/strong> is the entry point: YAML frontmatter between markers, followed by Markdown instructions.<\/p>\n Bundling a file is not enough on its own. Reference it explicitly from SKILL.md<\/strong> so Claude knows what it contains and when to open it:<\/p>\n Keep SKILL.md<\/strong> under about 500 lines.<\/p>\n This is where the products diverge, so it is worth being precise.<\/p>\n These two fields work everywhere:<\/p>\n In Claude Code, all frontmatter fields are optional<\/strong>. Only description<\/strong> is recommended, and if you omit it, Claude Code falls back to the first paragraph of the Markdown body. name<\/strong> defaults to the directory name.<\/p>\n Two of these deserve more attention than they usually get.<\/p>\n The web and desktop app is stricter, and this trips people up:<\/p>\n That 200-character description limit is a real constraint. Write it as one tight sentence covering what the skill does and when it applies.<\/p>\n For personal and project skills, the frontmatter name<\/strong> sets only on the display label. The command still comes from the directory name. For plugin skills, the name<\/strong> replaces the last segment of the command.<\/p>\n When names collide, enterprise overrides personal, and personal overrides project. A skill at any of these levels also overrides a bundled skill of the same name so a code-review<\/strong> skill in your project replaces the built-in \/code-review<\/strong>.<\/strong><\/p>\n Three behaviours worth knowing:<\/p>\n We will build a skill that analyses CSV datasets and checks row and column counts, missing values, duplicate records, column data types, high-cardinality columns, constant columns, numeric summaries, and other suspicious patterns.<\/p>\n For a project-level skill:<\/p>\n Resulting structure:<\/p>\n For personal skills available across all projects, use ~\/.<\/strong>claude<\/strong>\/skills\/<\/strong> instead.<\/p>\n Create .claude\/skills\/data-quality-auditor\/SKILL.md:<\/strong><\/p>\n Notice the allowed-tools<\/strong> line. It uses Create .clau<\/strong>de\/skills\/data-quality-auditor\/references\/data-quality-rules.md<\/strong>:<\/strong><\/p>\n Create .claude\/skills\/data-quality-auditor\/scripts\/profile_csv.py<\/strong>:<\/strong><\/p>\n The script performs the deterministic work: validating the file, loading it with Pandas, counting rows and columns, calculating missing-value percentages, detecting duplicates, extracting data types, finding constant and empty columns, separating high-cardinality categoricals from near-unique numeric columns, generating descriptive statistics, and returning everything as JSON.<\/p>\n Note how the script and the rules file agree. Earlier versions of this kind of skill often flag every near-unique column as \u201chigh cardinality,\u201d including integer primary keys, and then contradict a rules file that says the check applies to text columns. When the deterministic layer and the interpretive layer disagree, Claude produces confusing reports. Keep them aligned.<\/p>\n The division of responsibility is the point:<\/p>\n Python handles deterministic calculations. Claude handles interpretation and recommendations.<\/em><\/strong><\/p>\n Example output:<\/p>\n Resolve script errors before testing the skill through Claude Code.<\/p>\n Start Claude Code inside the project:<\/p>\n Invoke it directly:<\/p>\n Or use natural language and let Claude decide:<\/p>\n Audit data\/customers.csv and tell me whether it is ready for machine learning.<\/p>\n You can also stack skills at the start of a message. Typing \/write-tests \/fix-issue 123<\/strong> loads both skills and passes 123<\/strong> as the arguments to each. Expansion stops at the first token that is not an inline user-invocable skill.<\/p>\n You can also package the skill and upload it to claude.ai.<\/p>\n Skills require code execution.<\/p>\n The ZIP must contain the skill folder as its root not the loose files, and not a wrapper directory.<\/p>\n Correct:<\/strong><\/p>\n Incorrect:<\/strong> files sitting directly in the ZIP root.<\/p>\n Make sure the folder name matches the skill\u2019s name.<\/p>\n Skills you upload are private to your individual account unless an Owner provisions them organization-wide.<\/p>\n When you work on a skill with Claude in chat, the skill files open beside the conversation. Highlight the text you want changed, click Edit with Claude<\/strong>, and describe the change. For multi-file skills you can leave requests across several files and send them together, and Claude applies them in one pass.<\/p>\n On Pro, Max, and Team plans, in Cowork in Claude for Mac, you can record yourself performing a task and let Claude build the skill from the recording. Start it from the +<\/strong> button in the composer or from Customize \u2192 Skills \u2192 Add \u2192 Record your screen<\/strong>. Narrate as you work the commentary gives Claude context the screen alone does not.<\/p>\n Recordings run about ten minutes. Do not display passwords, secrets, or private conversations while recording; everything on screen is captured. The video and audio are not retained, but a set of screenshots is saved in the Cowork task.<\/p>\n This is not available in chat, on Windows, or on Free and Enterprise plans.<\/p>\n Custom Skills turn Claude from a general assistant into a system that follows your specific workflows.<\/p>\n A skill can be as simple as one Markdown file. No programming is required for basic workflows. For more advanced cases, it can bundle Python scripts, shell scripts, JavaScript utilities, templates, reference documents, validation logic, and example outputs.<\/p>\n The most effective approach is to start with one focused workflow audit a CSV dataset then write a clear description, define the workflow, specify the output format, test both relevant and irrelevant prompts, add code only where deterministic execution is required, and improve the skill based on actual failures rather than imagined ones.<\/p>\n The goal is not to store everything you know inside one skill. The goal is to capture one repeatable process and make it reliable.<\/p>\n Read more:<\/strong> How to Connect MCP Servers with Claude (Claude Desktop and Claude Code)<\/a><\/p>\n![\"Directory](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-1-3z965g-scaled.webp\")
<\/figure>\n<\/div>\nSkills and custom commands are now the same thing<\/h2>\n
Is Coding Required to Create a Claude Skill?<\/h2>\n
![\"Directory](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-2-3z965g-scaled.webp\")
<\/figure>\n<\/div>\n![\"Meeting](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-3-3z965g-scaled.webp\")
<\/figure>\n<\/div>\nWhen is code useful then?<\/h3>\n
\n
How Claude Skills Work<\/h2>\n
Stage 1: Discovery<\/h3>\n
![\"YAML](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-4-3z965g-scaled.webp\")
<\/figure>\n<\/div>\nStage 2: Instruction loading<\/h3>\n
Stage 3: Supporting resources<\/h3>\n
![\"File](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-5-3z965g-scaled.webp\")
<\/figure>\n<\/div>\nOne important consequence: skill content persists<\/h3>\n
\n
Anatomy of a Claude Skill<\/h2>\n
![\"Directory](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-6-3z965g-scaled.webp\")
<\/figure>\n<\/div>\n\n
references\/ <\/code>holds detailed information Claude may need coding standards, business rules, validation checklists.<\/li>\nexamples\/<\/code> shows what a good and a bad result looks like.<\/li>\ntemplates\/<\/code> provides a fixed output structure.<\/li>\nscripts\/<\/code> performs deterministic processing.<\/li>\n<\/ul>\n![\"Additional](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-7-3z965g-scaled.webp\")
<\/figure>\n<\/div>\nThe Frontmatter Reference<\/h2>\n
The portable core<\/h3>\n
\n\n
\n Field<\/strong><\/th>\n Purpose<\/strong><\/th>\n<\/tr>\n<\/thead>\n\n \n name<\/td>\n Identifier \/ display name for the skill<\/td>\n<\/tr>\n \n description<\/td>\n What the skill does and when to use it<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n Claude Code<\/h3>\n
\n\n
\n Field<\/strong><\/th>\n Description<\/strong><\/th>\n<\/tr>\n<\/thead>\n\n \n name<\/td>\n Display name in skill listings. Defaults to the directory name.<\/td>\n<\/tr>\n \n description<\/td>\n What does the skill do and when to use it. Claude matches against this.<\/td>\n<\/tr>\n \n when_to_use<\/td>\n Extra trigger phrases or example requests, appended to the description.<\/td>\n<\/tr>\n \n argument-hint<\/td>\n Autocomplete hint, e.g. [csv-file-path].<\/td>\n<\/tr>\n \n arguments<\/td>\n Named positional arguments for $name substitution.<\/td>\n<\/tr>\n \n disable-model-invocation<\/td>\n true prevents Claude from loading the skill automatically.<\/td>\n<\/tr>\n \n user-invocable<\/td>\n false hides the skill from the \/ menu.<\/td>\n<\/tr>\n \n allowed-tools<\/td>\n Tools Claude may use without a permission prompt during the invoking turn.<\/td>\n<\/tr>\n \n disallowed-tools<\/td>\n Tools removed from Claude\u2019s pool while the skill is active.<\/td>\n<\/tr>\n \n model<\/td>\n Model to use while the skill is active.<\/td>\n<\/tr>\n \n effort<\/td>\n Effort level: low, medium, high, xhigh, max.<\/td>\n<\/tr>\n \n context<\/td>\n Set to fork to run in a subagent context.<\/td>\n<\/tr>\n \n agent<\/td>\n Which subagent type to use with context: fork.<\/td>\n<\/tr>\n \n background<\/td>\n With context: fork, false waits for the result in the invoking turn.<\/td>\n<\/tr>\n \n hooks<\/td>\n Hooks scoped to this skill\u2019s lifecycle.<\/td>\n<\/tr>\n \n paths<\/td>\n Glob patterns limiting when the skill auto-activates.<\/td>\n<\/tr>\n \n shell<\/td>\n bash (default) or powershell for inline shell commands.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n \n
when_to_use<\/code> is where trigger phrases belong. Putting them in description <\/strong>bloats the field; when_to_use keeps the primary description clean while still feeding the matcher.<\/li>\npaths<\/code> <\/strong>limits automatic activation to files matching a glob. A skill for React conventions that only activates when Claude touches src\/**\/*.tsx<\/strong> will not fire during a database migration.<\/li>\n<\/ul>\nClaude.ai (uploaded skills)<\/h3>\n
\n
name<\/code> and description<\/code> are both required<\/strong><\/li>\nname<\/code>: 64 characters maximum<\/li>\ndescription<\/code>: 200 characters maximum<\/strong><\/li>\ndependencies<\/code> is an optional field for required packages, e.g. python>=3.8, pandas>=1.5.0<\/li>\n<\/ol>\nHow a skill gets its command name in Claude Code<\/h2>\n
\n\n
\n Location<\/strong><\/th>\n Command name comes from<\/strong><\/th>\n<\/tr>\n<\/thead>\n\n \n ~\/.claude\/skills\/deploy-staging\/SKILL.md<\/td>\n Directory name \u2192 \/deploy-staging<\/td>\n<\/tr>\n \n .claude\/commands\/deploy.md<\/td>\n File name \u2192 \/deploy<\/td>\n<\/tr>\n \n my-plugin\/skills\/review\/SKILL.md<\/td>\n Plugin-namespaced \u2192 \/my-plugin:review<\/td>\n<\/tr>\n \n Nested skill with a name clash<\/td>\n Directory-qualified \u2192 \/apps\/web:deploy<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n Where Skills Live<\/h2>\n
\n\n
\n Location<\/strong><\/th>\n Path<\/strong><\/th>\n Applies to<\/strong><\/th>\n<\/tr>\n<\/thead>\n\n \n Enterprise<\/td>\n Managed settings<\/td>\n All users in your organization<\/td>\n<\/tr>\n \n Personal<\/td>\n ~\/.claude\/skills\/ All your projects<\/td>\n<\/tr>\n \n Project<\/td>\n .claude\/skills\/ This project only<\/td>\n<\/tr>\n \n Plugin<\/td>\n Wherever the plugin is enabled<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n \n
.claude\/skills\/<\/code>.<\/li>\n<\/ul>\nHands-On Project: Building a Data Quality Auditor<\/h2>\n
Prerequisites<\/h3>\n
\n
Step 1: Create the skill directory<\/h3>\n
![\"Commands](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-8-3z965g-scaled.webp\")
<\/figure>\n<\/div>\n![\"Directory](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-9-3z965g-scaled.webp\")
<\/figure>\n<\/div>\nStep 2: Create SKILL.md<\/h3>\n
![\"Configuration](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-10-3z965g.webp\")
<\/figure>\n<\/div>\n${CLAUDE_SKILL_DIR}<\/code> in the permission rule *and* in the command the body tells Claude to run. Because both expand to the same path, the rule matches the exact command, and the script runs without a permission prompt. This is much narrower than a blanket Bash(python3 *)<\/strong>, which would pre-approve every Python invocation for that turn.<\/p>\nStep 3: Create the data-quality rules<\/h3>\n
![\"Markdown](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-11-3z965g.webp\")
<\/figure>\n<\/div>\nStep 4: Create the Python profiling script<\/h3>\n
from __future__ import annotations\n\nimport argparse\nimport json\nfrom pathlib import Path\nfrom typing import Any\n\nimport pandas as pd\n\ndef profile_csv(file_path: Path) -> dict[str, Any]:\n \"\"\"Generate a structured data-quality profile for a CSV file.\"\"\"\n\n if not file_path.exists():\n raise FileNotFoundError(f\"File not found: {file_path}\")\n if file_path.suffix.lower() != \".csv\":\n raise ValueError(\"The supplied file must have a .csv extension.\")\n\n try:\n dataframe = pd.read_csv(file_path)\n except pd.errors.EmptyDataError as exc:\n raise ValueError(\"The CSV file is empty.\") from exc\n except pd.errors.ParserError as exc:\n raise ValueError(\n \"The CSV file could not be parsed. Check its delimiter and structure.\"\n ) from exc\n\n row_count = len(dataframe)\n column_count = len(dataframe.columns)\n\n missing_count = dataframe.isna().sum()\n missing_percentage = (\n dataframe.isna().mean().mul(100).round(2)\n if row_count > 0\n else pd.Series(0.0, index=dataframe.columns)\n )\n\n missing_values = {\n column: {\n \"count\": int(missing_count[column]),\n \"percentage\": float(missing_percentage[column]),\n }\n for column in dataframe.columns\n if missing_count[column] > 0\n }\n\n duplicate_count = int(dataframe.duplicated().sum())\n duplicate_percentage = (\n round((duplicate_count \/ row_count) * 100, 2) if row_count > 0 else 0.0\n )\n\n data_types = {\n column: str(dtype) for column, dtype in dataframe.dtypes.items()\n }\n\n unique_counts = {\n column: int(dataframe[column].nunique(dropna=True))\n for column in dataframe.columns\n }\n\n # A constant column has exactly one distinct non-null value.\n # A column with zero distinct values is empty, which is a different problem.\n constant_columns = [\n column for column, count in unique_counts.items() if count == 1\n ]\n empty_columns = [\n column for column, count in unique_counts.items() if count == 0\n ]\n\n numeric_columns = set(dataframe.select_dtypes(include=\"number\").columns)\n\n high_cardinality_columns = []\n possible_encoded_identifiers = []\n\n for column in dataframe.columns:\n non_null_count = int(dataframe[column].notna().sum())\n if non_null_count == 0:\n continue\n\n uniqueness_ratio = unique_counts[column] \/ non_null_count\n if uniqueness_ratio None:\n parser = argparse.ArgumentParser(\n description=\"Profile a CSV file for common data-quality issues.\"\n )\n parser.add_argument(\"file_path\", type=Path, help=\"Path to the CSV file\")\n arguments = parser.parse_args()\n\n try:\n profile = profile_csv(arguments.file_path)\n print(json.dumps(profile, indent=2))\n except (FileNotFoundError, ValueError) as exc:\n print(json.dumps({\"success\": False, \"error\": str(exc)}, indent=2))\n raise SystemExit(1) from exc\n\n\nif __name__ == \"__main__\":\n main()<\/code><\/pre>\nWhat the script does<\/h3>\n
Step 5: Test the script directly<\/h3>\n
python3 .claude\/skills\/data-quality-auditor\/scripts\/profile_csv.py data\/customers.csv<\/code><\/pre>\n![\"JSON](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-12-3z965g.webp\")
<\/figure>\n<\/div>\nUsing the Skill in Claude Code<\/h2>\n
claude<\/code><\/pre>\n\/data-quality-auditor data\/customers.csv<\/code><\/pre>\nUploading the Skill to Claude (Web and Desktop)<\/h2>\n
Enable the prerequisites<\/h3>\n
\n
Package the skill<\/h3>\n
![\"Directory](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2026\/07\/image-13-3z965g-scaled.webp\")
<\/figure>\n<\/div>\nUpload<\/h3>\n
\n
Iterating in the app<\/h3>\n
Recording a skill instead of writing one<\/h3>\n
Conclusion<\/h2>\n