The appeal of Claude Projects isn't really up for debate anymore, it's proven its worth many times over since I've had my Pro subscription. There's no going back once you have a container with preloaded context. But at the same time, I'm also using my local LLM, especially since our internet provider has been a little unstable lately, so it's actually become really helpful during outages beyond just the appeal of a local-first workflow. The thing with local AI work, though, is that it doesn't have much in the way of workspace or productivity features, so you have to find workarounds.

Recently, I came across a tool called Fabric, which is meant to simplify repetitive LLM work. Combining that with my local LLM and Obsidian setup, I think I may have stumbled on a legit Claude Projects alternative.

Fabric is the part I didn't know I needed

Reusable prompts you don't have to keep writing

Fabric is a tool for running pre-written system prompts against a model of your choice. Daniel Miessler started it in early 2024 and the project has since been rewritten from Python into Go, which is the version anyone setting it up now should be using. The pre-written prompts are called Patterns and they're the whole point of the tool. Rather than a black box, each one is a markdown file you can open, read, and edit yourself, with a detailed system prompt inside that tells the model exactly how to handle whatever you feed it. The download includes more than 250 of them, ranging from the obvious ones like summarising and extracting key ideas to more specific jobs like rating content quality, writing in a particular voice, or pulling out the claims in a piece of writing.

CLI tools normally aren't my thing. I'm a designer in training, not a developer, so anything that lives entirely in a terminal usually doesn't make it into my stack. But Fabric on Windows installs through winget with a single command (winget install danielmiessler.Fabric), which made the first step much less painful than the coverage suggested it would be. The interactive setup, which runs from fabric --setup, is also pretty forgiving and walks you through downloading the patterns, picking your AI provider, and setting a default model. So my entry point wasn't a config file or a JSON edit, it was just answering prompts in the terminal.

Where the local LLM fits in

LM Studio runs the server, Fabric sends the prompts

The local LLM part of the setup actually happens inside that same Fabric setup screen, so they connect from the same spot. So opening LM Studio and typing into its chat window is the normal Gemma experience (for me, since E4B is my model of choice) and Fabric has nothing to do with it. The Patterns library never enters the picture and I might as well not even have Fabric installed. The Patterns only get applied when I switch over to PowerShell and run a Fabric command, which is the place the pre-written system prompts actually wrap around my input. The structure is generally fabric -u [link] -p [pattern] to point it at a web page, or pipe text in directly with something like echo "text" | fabric -p [pattern].

The other thing I had to adjust to is that Fabric is one-shot. There's no chat history or log of what I did yesterday, the response prints in the terminal and then just disappears when I close the window. Which sounds like a problem until you realise it's actually the reason the -o flag exists. Adding -o plus a file path to any Fabric command tells it to write the response into that file, so a full command might look like fabric -u [link] -p summarize -o [vault path]. That's the hook I needed to start treating my Obsidian vault as the place where these outputs can live.

And I can actually use this for the type of stuff that lives in my Claude Projects. It's useful for summarising research, pulling key points out of long pages, processing transcripts, breaking down dense chunks of information, and whatever else I usually handle in Claude Projects. So I just run one Fabric command against the source, the relevant Pattern handles the instructions for me, and I get a clean output back. The model isn't as strong as Claude, obviously, but the structure is there.

Obsidian brings it all together

A workspace built on file paths

Connecting Fabric to Obsidian is the least technical part of the whole setup, and not really a "connection" in the usual sense. Obsidian is just a folder of markdown files on disk, so all I did was add the -o flag to my Fabric commands and point at a path inside my vault. Whatever Fabric generates lands as a markdown file in that folder, and Obsidian picks it up automatically. A community plugin called Unofficial Fabric Integration wraps this in a proper Obsidian UI if you want.

This is where the one-shot thing can actually start working in your favor. Every Fabric output is just a regular note, so it's searchable, taggable, and linkable like the rest of my vault. The trick to making it feel like a Project is structuring the vault to act as the persistent layer Fabric doesn't have, so I keep inputs and outputs in separate folders with wikilinks between them. What this doesn't replicate is the part of Projects that keeps context live across chats, so the workspace coherence has to come from how I've organised the vault, not from the tool itself.

As close as I can get to local Projects

This setup gets me close to a local Projects setup, especially considering it's three free tools held together with file paths. Patterns handle the instructions, Obsidian handles the knowledge, and my local model handles the responses, and of course, it's all local and usable offline. So overall, I think it works as a real alternative for anyone who wants the local version of Projects for whatever reason.