Fabric

Fabric is an open-source AI prompt orchestration framework by Daniel Miessler. It provides a library of reusable AI prompts called Patterns — each designed for a specific real-world task — wired into a simple Unix pipeline with stdin/stdout.

When to use this skill

Summarize or extract insights from YouTube videos, articles, or documents
Apply any of 250+ pre-built AI patterns to content via Unix piping
Route different patterns to different AI providers (OpenAI, Claude, Gemini, etc.)
Create custom patterns for repeatable AI workflows
Run Fabric as a REST API server for integration with other tools
Process command output, files, or clipboard content through AI patterns
Use as an AI agent utility — pipe any tool output through patterns for intelligent summarization

Instructions

Step 1: Install Fabric

# macOS/Linux (one-liner)
curl -fsSL https://raw.githubusercontent.com/danielmiessler/fabric/main/scripts/installer/install.sh | bash

# macOS via Homebrew
brew install fabric-ai

# Windows
winget install danielmiessler.Fabric

# After install — configure API keys and default model
fabric --setup

Step 2: Learn the core pipeline workflow

Fabric works as a Unix pipe. Feed content through stdin and specify a pattern:

# Summarize a file
cat article.txt | fabric -p summarize

# Stream output in real time
cat document.txt | fabric -p extract_wisdom --stream

# Pipe any command output through a pattern
git log --oneline -20 | fabric -p summarize

# Process clipboard (macOS)
pbpaste | fabric -p summarize

# Pipe from curl
curl -s https://example.com/article | fabric -p summarize

Step 3: Discover patterns

# List all available patterns
fabric -l

# Update patterns from the repository
fabric -u

# Search patterns by keyword
fabric -l | grep summary
fabric -l | grep code
fabric -l | grep security

Key patterns:

Pattern	Purpose
`summarize`	Summarize any content into key points
`extract_wisdom`	Extract insights, quotes, habits, and lessons
`analyze_paper`	Break down academic papers into actionable insights
`explain_code`	Explain code in plain language
`write_essay`	Write essays from a topic or rough notes
`clean_text`	Remove noise and formatting from raw text
`analyze_claims`	Fact-check and assess credibility of claims
`create_summary`	Create a structured, markdown summary
`rate_content`	Rate and score content quality
`label_and_rate`	Categorize and score content
`improve_writing`	Polish and improve text clarity
`create_tags`	Generate relevant tags for content
`ask_secure_by_design`	Review code or systems for security issues
`capture_thinkers_work`	Extract the core ideas of a thinker or author
`create_investigation_visualization`	Create a visual map of complex investigations

Step 4: Process YouTube videos

# Summarize a YouTube video
fabric -y "https://youtube.com/watch?v=VIDEO_ID" -p summarize

# Extract key insights from a video
fabric -y "https://youtube.com/watch?v=VIDEO_ID" -p extract_wisdom

# Get transcript only (no pattern applied)
fabric -y "https://youtube.com/watch?v=VIDEO_ID" --transcript

# Transcript with timestamps
fabric -y "https://youtube.com/watch?v=VIDEO_ID" --transcript-with-timestamps

Step 5: Create custom patterns

Each pattern is a directory with a system.md file inside ~/.config/fabric/patterns/. The body should follow this structure:

mkdir -p ~/.config/fabric/patterns/my-pattern
cat > ~/.config/fabric/patterns/my-pattern/system.md << 'EOF'
# IDENTITY AND PURPOSE

You are an expert at [task]. Your job is to [specific goal].

Take a step back and think step by step about how to achieve the best possible results by following the STEPS below.

# STEPS

1. [Step 1]
2. [Step 2]

# OUTPUT INSTRUCTIONS

- Only output Markdown.
- [Format instruction 2]
- Do not give warnings or notes; only output the requested sections.

# INPUT

INPUT:
EOF

Use it immediately:

echo "input text" | fabric -p my-pattern
cat file.txt | fabric -p my-pattern --stream

Step 6: Multi-provider routing and advanced usage

# Run as REST API server (port 8080 by default)
fabric --serve

# Use web search capability
fabric -p analyze_claims --search "claim to verify"

# Per-pattern model routing in ~/.config/fabric/.env
FABRIC_MODEL_PATTERN_SUMMARIZE=anthropic|claude-opus-4-5
FABRIC_MODEL_PATTERN_EXTRACT_WISDOM=openai|gpt-4o
FABRIC_MODEL_PATTERN_EXPLAIN_CODE=google|gemini-2.0-flash

# Create shell aliases for frequently used patterns
alias summarize="fabric -p summarize"
alias wisdom="fabric -p extract_wisdom"
alias explain="fabric -p explain_code"

# Chain patterns
cat paper.txt | fabric -p summarize | fabric -p extract_wisdom

# Save output
cat document.txt | fabric -p extract_wisdom > insights.md

Step 7: Use in AI agent workflows

Fabric is a powerful utility for AI agents — pipe any tool output through patterns for intelligent analysis:

# Analyze test failures
npm test 2>&1 | fabric -p analyze_logs

# Summarize git history for a PR description
git log --oneline origin/main..HEAD | fabric -p create_summary

# Explain a code diff
git diff HEAD~1 | fabric -p explain_code

# Summarize build errors
make build 2>&1 | fabric -p summarize

# Analyze security vulnerabilities in code
cat src/auth.py | fabric -p ask_secure_by_design

# Process log files
cat /var/log/app.log | tail -100 | fabric -p analyze_logs

REST API server mode

Run Fabric as a microservice and call it from other tools:

# Start server
fabric --serve --port 8080

# Call via HTTP
curl -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"prompts":[{"userInput":"Summarize this","patternName":"summarize"}]}'

Best practices

Run fabric -u before first use and regularly to get the latest community patterns.
Use --stream for long content to see results progressively instead of waiting.
Create shell aliases (alias wisdom="fabric -p extract_wisdom") for your most-used patterns.
Use per-pattern model routing to optimize cost vs. quality for each task type.
Keep custom patterns in ~/.config/fabric/patterns/ — they persist across updates.
For YouTube, transcript extraction works best with videos that have captions enabled.
Chain patterns with Unix pipes for multi-step processing workflows.
Follow the IDENTITY → STEPS → OUTPUT INSTRUCTIONS structure when creating custom patterns.

fabric