How to Create and Use Custom Patterns in Fabric: A Complete Guide

Fabric enables you to create reusable prompt packages in a dedicated directory that persists across updates, with custom patterns automatically taking precedence over built-in ones when names collide.

The danielmiessler/fabric CLI tool treats a pattern as a reusable prompt package containing system instructions, user templates, and optional configuration files. While Fabric ships with built-in patterns stored in data/patterns, creating custom patterns allows you to extend functionality without risking overwrite during upgrades. This guide explains the complete workflow from initial setup to execution, based on the actual source code implementation.

Understanding the Custom Patterns Architecture

The custom patterns system relies on three core components working together to load and prioritize your private prompts.

The CustomPatterns Plugin

Located in internal/tools/custom_patterns/custom_patterns.go, the CustomPatterns plugin handles the initial configuration. It registers an interactive setup question that prompts you for a directory path, expands the ~ home directory shortcut, resolves the absolute path, and creates the folder if it does not exist. The plugin exposes an IsConfigured() method that verifies whether a custom directory has been set before the application attempts to load patterns.

The PatternsLoader Merge Logic

In internal/tools/patterns_loader.go, the PatternsLoader orchestrates pattern discovery. During initialization, it scans both the built-in directory (o.Patterns.Dir) and your custom path stored in CustomPatterns.CustomPatternsDir. It merges these into a single map, with custom patterns taking precedence because they are added to the map after the built-in ones. This means if both directories contain a pattern named summarize, Fabric automatically uses your custom version.

PluginRegistry Integration

The internal/core/plugin_registry.go file wires the CustomPatterns plugin into Fabric's global registry. This integration ensures your custom directory participates in the interactive fabric --setup flow and that the path is written to the generated .env file as CUSTOM_PATTERNS_DIRECTORY. Because the configuration persists in .env, your custom patterns remain available across application restarts and upgrades.

Setting Up Your Custom Patterns Directory

You can configure the custom patterns directory through the interactive setup or manual environment configuration.

Interactive Setup Method

Run the setup command and specify your preferred storage location:

fabric --setup

When prompted for Custom Patterns, enter an absolute or relative path such as ~/my-custom-patterns. Fabric automatically expands the path, creates the directory structure if missing, and writes the configuration to your .env file.

Manual Environment Configuration

Alternatively, set the directory directly in your .env file using the CUSTOM_PATTERNS_DIRECTORY variable:

CUSTOM_PATTERNS_DIRECTORY=/home/user/personal-patterns

When the environment loads, CustomPatterns.IsConfigured() returns true and the PatternsLoader automatically includes this path in its scan.

Creating a Custom Pattern

Each subfolder in your custom directory represents a distinct pattern, following the same structure as built-in patterns.

Required File Structure

Create a new folder inside your custom patterns directory. The folder name becomes the pattern identifier used with the --pattern flag. At minimum, you must include:

• system.md: Contains the system prompt instructions that define the AI's behavior
• user.md: (Optional) Template for user-specific inputs
• config.json: (Optional) Additional configuration parameters

For example, to create a pattern called security-analyzer:

mkdir -p ~/my-custom-patterns/security-analyzer
cat > ~/my-custom-patterns/security-analyzer/system.md <<'EOF'
You are a cybersecurity expert. Analyze the input for vulnerabilities and provide remediation steps. Be concise and technical.
EOF

Using Custom Patterns in Commands

Once configured, custom patterns integrate seamlessly with standard Fabric workflows.

Listing Available Patterns

Run the following command to see both built-in and custom patterns:

fabric --listpatterns

Custom patterns appear alongside built-in options, allowing you to verify that Fabric detected your new templates.

Executing Custom Patterns

Invoke your pattern using the standard --pattern flag:

fabric --pattern security-analyzer "Review this firewall configuration"

Fabric resolves the directory, loads your custom system.md, and applies it to the request. If a built-in pattern shares the same name as your custom one, Fabric automatically selects your custom version due to the merge precedence logic in internal/tools/patterns_loader.go.

Summary

• The CustomPatterns plugin in internal/tools/custom_patterns/custom_patterns.go manages directory configuration through interactive setup or the CUSTOM_PATTERNS_DIRECTORY environment variable.
• PatternsLoader automatically merges built-in and custom directories, with custom patterns taking precedence when names collide.
• Each custom pattern requires a folder containing at least a system.md file, with optional user.md and config.json files for advanced configurations.
• Custom patterns persist across Fabric updates because they reside outside the core data/patterns directory and store their path in the .env file.

Frequently Asked Questions

Where does Fabric store the custom patterns configuration?

Fabric stores the custom patterns path in the .env file under the variable CUSTOM_PATTERNS_DIRECTORY. This value is written during the interactive fabric --setup process or can be set manually. The CustomPatterns plugin reads this variable at runtime to determine where to scan for user-defined patterns.

What files are required to create a valid custom pattern?

You must include a system.md file inside a folder named after your pattern. This file contains the system instructions that define the AI's role and behavior. While user.md and config.json are optional, following the standard pattern structure ensures compatibility with Fabric's loading mechanisms.

Do custom patterns override built-in patterns with the same name?

Yes. When PatternsLoader builds the pattern map in internal/tools/patterns_loader.go, it loads custom patterns after built-in ones. This sequence ensures that custom entries overwrite built-in entries in the map, giving your private prompts automatic precedence without requiring special flags or configuration changes.

Can I use environment variables instead of interactive setup for custom patterns?

Yes. You can manually set CUSTOM_PATTERNS_DIRECTORY in your .env file or export it as an environment variable before running Fabric. The CustomPatterns plugin checks IsConfigured() by verifying this variable exists, allowing the PatternsLoader to include your custom directory without ever running the interactive setup wizard.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}