This is a from the drawer post. I was reaching for Fabric a couple of years ago, well before everyone started talking about agents, and looking back it quietly nailed something the whole industry rediscovered later. So I want to write down what it got right, because the lesson aged extremely well.
If you have not seen it: Fabric is an open-source project by Daniel Miessler, framed as a framework for augmenting humans using AI. His line was that AI does not have a capabilities problem, it has an integration problem. The model is smart enough. What is missing is the plumbing that lets you point that intelligence at a real task, repeatedly, without retyping the same instructions every single time. That framing alone was sharper than most of what I was reading back then.
What Fabric actually is
The core idea is Patterns. A Pattern is a curated prompt, written as plain markdown (a system.md file), that solves one specific job: summarize this, extract the wisdom from that transcript, analyze these claims, turn this into a threat model. The Patterns live in a folder, under version control, and you call them from the command line. There are a couple hundred of them in the repo, contributed by a crowd of people, so you are not starting from a blank box.
And because it is CLI-first, it composes the way Unix tools compose. You pipe text in, you get structured output back:
cat article.txt | fabric --pattern extract_wisdom
That is the whole trick. Input on stdin, a named Pattern does the transformation, result on stdout, ready to pipe into the next thing. It reads a URL, a file, a transcript, whatever, and runs it through the Pattern you chose. Later it was rewritten from Python to Go and shipped as a single binary, which made it even easier to drop into a workflow. It is also vendor agnostic: OpenAI, Anthropic, Ollama, plenty of others, so you are not locked to one provider.
Why that was ahead of its time
Here is the part that matters. Back then, the default way to use a model was to open a web box and chat. Every good prompt you wrote lived for exactly one conversation and then evaporated. Next week you needed the same thing, you wrote it again, slightly worse, from memory. People hoarded screenshots and bookmarked clever ChatGPT threads like they were recipes. It was all ephemeral.
Fabric refused to play that game. It treated a prompt as a durable artifact, the same way you treat a function or a script. Think about what falls out of that one decision:
- Reusable. You write the prompt once and call it forever. The good version, not the from-memory version.
- Version-controlled. The Patterns are markdown in git. You can diff them, improve them, roll them back, see why you changed something. Prompts get a history, like code.
- Shareable. A Pattern is a file. You can hand it to a colleague, publish it, or pull someone else's. The good prompt stops being trapped in one person's head.
- Composable. Because it is CLI and stdin/stdout, a Pattern is a building block. You chain them, you script around them, you wire them into the tools you already use.
None of those four properties existed in the chat-in-a-box workflow. Fabric had all of them in 2024.
What it foreshadowed
Now look at where serious AI tooling actually went. Every idea I listed is now mainstream, just under different names.
A CLAUDE.md in your repo is a version-controlled, reusable instruction set that travels with the project. That is a Pattern, basically: durable prompt-as-file, in git, shared with everyone who clones the repo. Skills are reusable, named capabilities you invoke instead of re-explaining the task each time. Same instinct. The prompt libraries and prompt registries that teams now maintain are just Fabric's Patterns folder with a nicer UI. The whole move from chat to agentic, CLI-driven, composable tooling, where you pipe context through named operations and chain steps together, is the exact shape Fabric was already in.
The deep insight Fabric had early, and that everyone arrived at independently later, is this: a prompt is not a message, it is a piece of tooling. Once you believe that, you stop typing into a box and you start building a library. You version it, you test it, you share it, you compose it. That mental model is now the default for anyone doing real work with these models, and Fabric was living there two years ahead.
So would I use it today?
Honestly, my own daily driver now is agentic tooling that has absorbed most of these ideas natively, so I do not reach for Fabric as often as I did. But that is not a knock on it. It is a sign that the idea won. The project is still alive, still has a big crowd of contributors, and the catalogue of Patterns is genuinely useful if you want quick, repeatable transformations from the terminal without standing up a whole agent setup.
The reason I am writing this is not nostalgia. It is that the early tools usually tell you where things are going, if you read them right. Fabric was anti-hype before anti-hype was a posture: no chat theater, no magic, just treat your prompts like the durable, composable tooling they always should have been. That call was correct. It just took the rest of us a couple of years to catch up.