MSFM: The Markdown That Compiles Into Full-Stack Apps
MSFM (MindStudio-Flavored Markdown) is the plan Remy compiles into an app: readable prose plus structured precision. Here's what it is, why it exists, and why you don't hand-write it.
What is MSFM?
MSFM—MindStudio-Flavored Markdown—is the format Remy compiles into a working application. It’s plain markdown with one addition: alongside the readable prose that describes what an app does, MSFM carries structured precision—the data types, schemas, rules, and references a compiler needs to turn that description into a real backend, database, auth system, and frontend.
The important part up front: you don’t hand-write MSFM. You describe the app in plain language, Remy drafts the MSFM spec, and you read and approve it. The format exists so that one document can be readable by a human and precise enough for a compiler—the foundation that makes spec-driven development work.
TL;DR
- MSFM is plain markdown plus structured precision—readable prose for humans, typed detail (schemas, rules, references) for the compiler, in one document.
- You don’t write MSFM by hand—you describe the app, Remy drafts the spec, and you review and approve it in plain language.
- It’s the source of truth Remy compiles from: edit the plan and recompile, and the backend, database, auth, and frontend regenerate to match.
- Because it’s just markdown, it renders anywhere—GitHub, an editor, or pasted into any model—so your plan isn’t trapped in one tool.
- It splits a spec into two layers: a narrative anyone can read, and annotations that pin down the exact types and rules the code is generated from.
- When a stronger model ships, Remy recompiles the same MSFM into a better app—the plan stays put, the output improves.
- The full syntax lives in the MSFM walkthrough; this page is the what and the why.
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
The two layers: readable prose + precision
Code is precise but hard to skim. Prose is readable but ambiguous. MSFM sits in between by carrying both at once.
The prose layer is the narrative—what the app does, who uses it, what each screen should feel like. Anyone can read it, the same way they’d read a product brief.
The precision layer is structured detail attached to that prose—the exact type of a field, the columns in a table, the rule behind a status, the color behind “green.” A human skims past it; the compiler reads it as the contract it generates code from.
A tiny taste of the idea: a line might read “the primary button is green” for a person, while carrying a structured note that pins “green” to an exact value and design token for the compiler. You read the sentence; Remy reads the precision. (The actual annotation syntax—how those notes are written—is covered in the MSFM walkthrough.)
That two-layer structure is the whole trick: one document that a person understands and a compiler can build from, with no second “technical spec” to keep in sync.
Why MSFM exists
A spec has to do two jobs at once: be readable enough that you can reason about the product, and precise enough that an app can be generated from it. Most formats pick one side. Raw code is precise and unreadable to non-engineers; a prose doc is readable and too vague to compile. MSFM is built to do both, which is what lets the plan—not the code—be the source of truth.
Three things follow from that:
- Humans and AI read the same document. Hand it to a teammate and they understand the app; hand it to Remy and it compiles the stack. No translation step.
- It’s portable by default. Because it’s plain markdown, it renders in GitHub, any editor, or a chat window. The plan is yours—you can read it, version it, and hand it to a different model later.
- It improves as models improve. The plan is the input, so a better model recompiles the same MSFM into better code automatically—no rewriting, no re-prompting.
You don’t write MSFM—Remy does
This is the part people expect to be hard and isn’t. You don’t learn a syntax or fill in templates. You describe the app—by voice, text, or a pasted document—and Remy drafts the MSFM for you: the prose, the structure, the precision. You read it back in plain language, adjust anything that’s off, and approve it.
If you want to write or edit MSFM directly—or you’re building on the MindStudio platform outside of Remy—the format is documented and the syntax is straightforward. The MSFM walkthrough covers it primitive by primitive. But for most people, the workflow is describe → review → approve, and the syntax stays under the hood.
How MSFM compares to other annotated-prose formats
MSFM isn’t the first attempt to blend narrative and code—literate programming, Jupyter notebooks, and MDX all tried. What sets MSFM apart:
- It renders as plain markdown. No custom viewer required—any markdown renderer shows a readable document, so a spec is legible in more places than MDX or a notebook.
- It’s designed for models to read and write. The structure is regular enough that an LLM can generate valid MSFM and parse it back, which is what makes the describe-and-draft loop work.
- It compiles to a full stack. The annotations aren’t documentation hints—they’re the contract a compiler turns into a backend, database, frontend, and deployment.
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
What you can build with it
MSFM is general-purpose—anything you can describe, Remy can compile. In practice that’s the full range of full-stack web apps:
- Internal tools — approval workflows, vendor management, moderation queues
- Vertical SaaS — CRMs, project trackers, client portals
- AI-powered apps — content generators, image editors, task agents
- Multi-interface apps — a web frontend, a REST API, bots, and scheduled jobs, all from one plan
The boundary is the platform’s capabilities (full-stack web apps, not native mobile). Within that, MSFM is flexible enough to describe most products. For how one plan fans out across surfaces, see one method, eight interfaces; for how the layers fit together, see Remy’s three-layer model.
FAQ
Do I need to learn MSFM to use Remy?
No. You describe what you want in plain language and Remy drafts the MSFM. You review and approve it—editing the syntax directly is optional, and most people never do.
Can I take my MSFM spec elsewhere?
Yes. It’s plain markdown, so the plan is fully portable—readable in any editor and parseable by any capable model. The compiled code (TypeScript, SQL, React) is yours too. The managed runtime—database, auth, deployment—is the platform layer; the plan and the code travel with you.
Can I use MSFM outside of Remy?
Yes. It’s the annotation format for the MindStudio platform, so developers building on the platform directly can write MSFM specs by hand. Same format, different entry point—the developer guide has the full reference.
What happens if I edit the spec after Remy drafts it?
That’s the normal loop. Edit the plan and Remy recompiles the code to match. The plan is the source of truth, so changes flow from it.
How does MSFM stay useful as AI models improve?
Because the plan is the source of truth, a better model means Remy recompiles the same MSFM into a better app—newer patterns, cleaner code—without you rewriting anything.
The bottom line
MSFM is what makes spec-driven development work: a single document that’s readable enough for a person and precise enough for a compiler. You don’t write it—you describe an app, Remy drafts the plan, and you approve it. It’s plain markdown, so it’s portable and it outlives any one tool, and because it’s the source of truth, the app it compiles keeps getting better as models do.
Remy is a product agent that compiles MSFM into a full-stack app—backend, database, frontend, auth, tests, and deployment—in a single step. If you want to see the format in action, start building with Remy →, or read the MSFM walkthrough for the full syntax.
