I get it. ChatGPT is right there in the browser, it has history, it has a nice UI. But after using Fabric for a few months, I'm convinced that developers who haven't tried it are leaving real productivity on the table.
What Fabric Actually Is
Fabric is a CLI tool built by Daniel Miessler. At its core, it's a framework for wrapping AI prompts into reusable, composable commands. You install it, point it at an AI provider, and then run things like:
fabric --pattern summarize < article.txt
fabric --pattern extract_wisdom < podcast_transcript.txt
pb paste | fabric --pattern improve_writing | pb copy
The patterns are just markdown files with a system prompt. You can use the built-in library of 100+ patterns, or write your own. They live in ~/.config/fabric/patterns/.
The Real Problem with ChatGPT for Developers
ChatGPT is a great interface for people who occasionally use AI. For developers who want to integrate AI into their actual workflow — it's friction-heavy.
Every time you want to do something with the ChatGPT UI, you're doing it manually:
- Open browser
- Navigate to chat
- Paste your content
- Type your instructions (again, because you didn't save the prompt)
- Copy the output
That's fine for one-offs. It's terrible for anything you do repeatedly.
What CLI-First Gets You
With Fabric (or any CLI-first AI tool), you get composability. Unix pipes. The ability to chain AI operations with real tools.
# Summarize the last 50 lines of your server logs
tail -n 50 /var/log/app.log | fabric --pattern summarize
# Get meeting notes from a transcript
cat meeting.txt | fabric --pattern create_tags | fabric --pattern summarize
You can script this. You can put it in a Makefile. You can hook it into git hooks, CI pipelines, shell aliases. The AI becomes part of your toolchain, not a separate tab you switch to.
Pattern Reuse Is the Killer Feature
The patterns are the real win. Once you write a pattern for something — "extract action items from this meeting," "review this pull request diff," "translate this error message into plain English" — you never have to think about that prompt again. It's codified.
ChatGPT has "custom instructions" but they're global. Fabric patterns are composable, version-controlled, and shareable. Push your patterns to a git repo and your whole team uses the same prompts.
Trade-offs to Be Honest About
Fabric isn't perfect:
- No persistent memory — Each call is stateless. If your workflow needs multi-turn conversation, Fabric isn't the right fit.
- Setup overhead — You need an API key and to install the Go binary. It's not for non-technical users.
- No image input — Text-only by default, though this is improving.
For exploratory conversations, debugging something I don't understand yet, or anything that benefits from back-and-forth — I still use a chat interface. But for anything repeatable? Fabric wins.
The Principle Behind It
The deeper point isn't about Fabric specifically. It's that the best AI interface for developers is the one that integrates with existing tools. The terminal is already where developers work. Bringing AI into that environment — rather than context-switching out of it — is just better ergonomics.
If you haven't tried it: brew install fabric-ai and spend 20 minutes with the built-in patterns. You'll find at least three things you'll want to keep.