mcpbeat Sign in

Create Llms Agent Skill

Create an llms.txt file from scratch based on repository structure following the llms.txt specification at https://llmstxt.org/

2k tokens
context cost
the whole folder, loaded on every use
1
files
instructions only
1
copies elsewhere
how many repositories repackaged it
37394
stars on the repo
on the repository, not the skill itself

Install

one command, takes just this skill from the repository
npx skills add https://github.com/github/awesome-copilot --skill create-llms

The instruction itself

27 sections, as written by the author

Create LLMs.txt File from Repository Structure

Create a new llms.txt file from scratch in the root of the repository following the official llms.txt specification at https://llmstxt.org/. This file provides high-level guidance to large language models (LLMs) on where to find relevant content for understanding the repository's purpose and specifications.

Primary Directive

Create a comprehensive llms.txt file that serves as an entry point for LLMs to understand and navigate the repository effectively. The file must comply with the llms.txt specification and be optimized for LLM consumption while remaining human-readable.

Analysis and Planning Phase

Before creating the llms.txt file, you must complete a thorough analysis:

Step 1: Review llms.txt Specification

  • Review the official specification at https://llmstxt.org/ to ensure full compliance
  • Understand the required format structure and guidelines
  • Note the specific markdown structure requirements

Step 2: Repository Structure Analysis

  • Examine the complete repository structure using appropriate tools
  • Identify the primary purpose and scope of the repository
  • Catalog all important directories and their purposes
  • List key files that would be valuable for LLM understanding

Step 3: Content Discovery

  • Identify README files and their locations
  • Find documentation files (.md files in /docs/, /spec/, etc.)
  • Locate specification files and their purposes
  • Discover configuration files and their relevance
  • Find example files and code samples
  • Identify any existing documentation structure

Step 4: Create Implementation Plan

Based on your analysis, create a structured plan that includes:

  • Repository purpose and scope summary
  • Priority-ordered list of essential files for LLM understanding
  • Secondary files that provide additional context
  • Organizational structure for the llms.txt file

Implementation Requirements

Format Compliance

The llms.txt file must follow this exact structure per the specification:

  • H1 Header: Single line with repository/project name (required)
  • Blockquote Summary: Brief description in blockquote format (optional but recommended)
  • Additional Details: Zero or more markdown sections without headings for context
  • File List Sections: Zero or more H2 sections containing markdown lists of links

Content Requirements

Required Elements
  • Project Name: Clear, descriptive title as H1
  • Summary: Concise blockquote explaining the repository's purpose
  • Key Files: Essential files organized by category (H2 sections)

Each file link must follow: descriptive-name: optional description

Section Organization

Organize files into logical H2 sections such as:

  • Documentation: Core documentation files
  • Specifications: Technical specifications and requirements
  • Examples: Sample code and usage examples
  • Configuration: Setup and configuration files
  • Optional: Secondary files (special meaning - can be skipped for shorter context)

Content Guidelines

Language and Style
  • Use concise, clear, unambiguous language
  • Avoid jargon without explanation
  • Write for both human and LLM readers
  • Be specific and informative in descriptions
File Selection Criteria

Include files that:

  • Explain the repository's purpose and scope
  • Provide essential technical documentation
  • Show usage examples and patterns
  • Define interfaces and specifications
  • Contain configuration and setup instructions

Exclude files that:

  • Are purely implementation details
  • Contain redundant information
  • Are build artifacts or generated content
  • Are not relevant to understanding the project

Execution Steps

Step 1: Repository Analysis

  • Examine the repository structure completely
  • Read the main README.md to understand the project
  • Identify all documentation directories and files
  • Catalog specification files and their purposes
  • Find example files and configuration files

Step 2: Content Planning

  • Determine the primary purpose statement
  • Write a concise summary for the blockquote
  • Group identified files into logical categories
  • Prioritize files by importance for LLM understanding
  • Create descriptions for each file link

Step 3: File Creation

  • Create the llms.txt file in the repository root
  • Follow the exact format specification
  • Include all required sections
  • Use proper markdown formatting
  • Ensure all links are valid relative paths

Step 4: Validation

  • Verify compliance with https://llmstxt.org/ specification
  • Check that all links are valid and accessible
  • Ensure the file serves as an effective LLM navigation tool
  • Confirm the file is both human and machine readable

Quality Assurance

Format Validation

  • ✅ H1 header with project name
  • ✅ Blockquote summary (if included)
  • ✅ H2 sections for file lists
  • ✅ Proper markdown link format
  • ✅ No broken or invalid links
  • ✅ Consistent formatting throughout

Content Validation

  • ✅ Clear, unambiguous language
  • ✅ Comprehensive coverage of essential files
  • ✅ Logical organization of content
  • ✅ Appropriate file descriptions
  • ✅ Serves as effective LLM navigation tool

Specification Compliance

  • ✅ Follows https://llmstxt.org/ format exactly
  • ✅ Uses required markdown structure
  • ✅ Implements optional sections appropriately
  • ✅ File located at repository root (/llms.txt)

Example Structure Template

# [Repository Name]

> [Concise description of the repository's purpose and scope]

[Optional additional context paragraphs without headings]

## Documentation

- [Main README](README.md): Primary project documentation and getting started guide
- [Contributing Guide](CONTRIBUTING.md): Guidelines for contributing to the project
- [Code of Conduct](CODE_OF_CONDUCT.md): Community guidelines and expectations

## Specifications

- [Technical Specification](spec/technical-spec.md): Detailed technical requirements and constraints
- [API Specification](spec/api-spec.md): Interface definitions and data contracts

## Examples

- [Basic Example](examples/basic-usage.md): Simple usage demonstration
- [Advanced Example](examples/advanced-usage.md): Complex implementation patterns

## Configuration

- [Setup Guide](docs/setup.md): Installation and configuration instructions
- [Deployment Guide](docs/deployment.md): Production deployment guidelines

## Optional

- [Architecture Documentation](docs/architecture.md): Detailed system architecture
- [Design Decisions](docs/decisions.md): Historical design decision records

Success Criteria

The created llms.txt file should:

  • Enable LLMs to quickly understand the repository's purpose
  • Provide clear navigation to essential documentation
  • Follow the official llms.txt specification exactly
  • Be comprehensive yet concise
  • Serve both human and machine readers effectively
  • Include all critical files for project understanding
  • Use clear, unambiguous language throughout
  • Organize content logically for easy consumption

Other skills for the same job

different authors, same section of the catalogue
At Dispatch V2
by pytorch
vendor ×3

Convert PyTorch AT_DISPATCH macros to AT_DISPATCH_V2 format in ATen C++ code. Use when porting AT_DISPATCH_ALL_TYPES_AND*, AT_DISPATCH_FLOATING_TYPES*, or other dispatch macros to the new v2 API. For ATen kernel files, CUDA kernels, and native operator implementations.

2k tokens
Docstring
by pytorch
vendor ×3

Write docstrings for PyTorch functions and methods following PyTorch conventions. Use when writing or updating docstrings in PyTorch code.

3k tokens
Statsmodels
by christophacham
×3

Statistical models library for Python. Use when you need specific model classes (OLS, GLM, mixed models, ARIMA) with detailed diagnostics, residuals, and inference. Best for econometrics, time series, rigorous inference with coefficient tables. For guided statistical test selection with APA reporting use statistical-analysis.

27k tokens
AI SDK
by vercel-labs
vendor ×2

Answer questions about the AI SDK and help build AI-powered features. Use when developers: (1) Ask about AI SDK functions like generateText, streamText, ToolLoopAgent, embed, or tools, (2) Want to build AI agents, chatbots, RAG systems, or text generation features, (3) Have questions about AI providers (OpenAI, Anthropic, Google, etc.), streaming, tool calling, structured output, or embeddings, (4) Use React hooks like useChat or useCompletion. Triggers on: "AI SDK", "Vercel AI SDK", "generateText", "streamText", "add AI to my app", "build an agent", "tool calling", "structured output", "useChat".

6k tokens
Esm
by K-Dense-AI
×1

Use when working directly with the `esm` Python SDK, ESM3 or ESMC model IDs, Forge/Biohub inference clients, or ESMFold2 folding workflows.

21k tokens
Modal
by K-Dense-AI
×1

Modal is a serverless cloud platform for running Python on demand, including on-demand GPUs. Use when deploying or serving AI/ML models, running GPU-accelerated workloads (training, fine-tuning, inference), serving web endpoints, scheduling batch jobs, or scaling Python code to cloud containers with the Modal SDK.

19k tokens
Pytdc
by K-Dense-AI
×1

Use Therapeutics Data Commons through the PyTDC Python package for registry discovery, approved dataset access, task-aware splits, evaluator metrics, benchmark groups, and bounded molecular-oracle workflows.

27k tokens scripts
Scikit Learn
by K-Dense-AI
×1

Machine learning in Python with scikit-learn. Use when working with supervised learning (classification, regression), unsupervised learning (clustering, dimensionality reduction), model evaluation, hyperparameter tuning, preprocessing, or building ML pipelines. Provides comprehensive reference documentation for algorithms, preprocessing techniques, pipelines, and best practices.

30k tokens scripts

How to use it

Copy the folder

Take github/create-llms from the repository into ~/.claude/skills for personal use, or into .claude/skills inside a project.

Check the name does not clash

The agent identifies a skill by the name field in its header. Two skills with the same name cannot sit side by side — one of them will be ignored.