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.

References

• Fabric GitHub

• Pattern Library

• Installation Guide

• Custom Pattern Guide

Provider Configuration

• LM Studio 설정 가이드 — LM Studio를 로컬 AI 백엔드로 설정하는 방법 (오프라인·프라이버시 환경)