Building in Public | Is an MCP Server enough?
TL;DR An MCP server would let a configured AI assistant call my calculator, but it would not solve the discovery problem. A public article could make the calculation easier to find, although it would leave the assistant responsible for interpreting and applying the instructions. Now I’m wondering how to prevent those instructions from drifting away from the tested calculator library, and whether their worked examples could be generated or verified by the library itself.
The Discovery Problem
The other day, I decided that bringing my knitting calculator to AI assistants would mean creating an MCP server. And I am going to create one. It could bring value to (a few) users, it will be a great learning experience for me, and it will be a total tech flex. Don't mind if I do! But I keep returning to the same question: do people really browse plugin directories looking for MCP servers? I'm sure some heavy users of Codex and Claude Code do, along with tech enthusiasts and software developers like me. But I have a harder time imagining knitters who aren't software developers doing the same. And I keep thinking: if I want as many AI assistants to use my knitting calculator as possible, wouldn't I be better off simply writing the instructions in natural language and publishing them on a website where assistants could find them?
Limitations
The simple answer is yes. I can absolutely write a set of instructions for an AI assistant to follow and publish them on a website. And I suspect more knitters would benefit from those instructions indirectly through an assistant than would connect their assistant to my MCP server.
But this does not guarantee that lots of AI assistants will start using my instructions. An assistant would still need to:
have web search available and enabled;
decide to search rather than answer from its existing knowledge;
formulate a search that surfaces my article;
choose my article among the results;
interpret and apply the instructions correctly.
That is a decent number of stars that need to align.
There is also an important distinction between an MCP server and a set of instructions on a website. They solve slightly different problems:
An article gives an assistant instructions it can read and follow.
An API or MCP tool lets an assistant call software that performs the calculation for it.
If an assistant finds my article, it can read the instructions, apply them to the knitter’s numbers, and perhaps cite my page. This would give knitters another way to access my calculation method. They would not need to install a plugin or configure an MCP server; an assistant with web search could use the instructions directly.
The article would not replace my MCP server. It would make the method available even when an assistant had not been connected to it. The trade-off is that the assistant’s underlying model must interpret the instructions, perform the calculation, and present the result accurately. With an MCP tool, the model would still need to understand the knitter’s request and communicate the answer, but my tested calculator library would handle the calculation itself.
Publishing instructions might give me broader reach, but it would also leave more of the experience outside my control.
How would I do it?
You are probably thinking, “How would you do it? Just type up the instructions, choose a nice font, and hit 'Publish'. What more is there?”
But I, of course, can find a way to make anything more complicated.
My first thought was that I could somehow derive the written instructions directly from my calculator library. But should I do that? Is source code even the right raw material for a natural-language explanation?
Even if I write the instructions myself, I still want them to remain connected to the calculator. When I update the library to handle a new edge case, how will I make sure the instructions do not become outdated? Could an automated pipeline update them, or at least alert me that they need attention?
The instructions would be ordinary prose rather than executable code, so I could not unit-test every sentence in quite the same way. But perhaps I could generate or verify their worked examples using the calculator library itself.
At that point, the instructions stop being merely documentation. They become another interface to the calculator, this time designed for AI assistants.
And that leads to the much more interesting problem: how do I prevent the written instructions and the executable calculation from drifting apart?
Can prose be tested like software?
Not exactly. I cannot unit-test every sentence of a natural-language explanation in the same way that I can unit-test executable code. But I can test the concrete claims and worked examples within it.
Rather than returning only a finished knitting instruction, my calculator library could return a structured calculation result. It might keep the starting stitch count, target stitch count, type of operation, number of stitches being added or removed, and calculated distribution as separate pieces of data.
Each interface could then present that same result differently. The command-line tool could print a sentence, the API could return JSON, and the article could use it to construct a worked example.
I could also store the article’s examples as structured test cases and run them through the library whenever the website is built. If I changed the calculator to handle a new edge case, the examples could be regenerated automatically, or the build could alert me when an existing example no longer matched the calculator’s result.
That would not verify every sentence in the general instructions. But it could ensure that every numerical example agreed with the calculator library.
I could even test the instructions themselves by giving them to AI assistants along with stitch counts they had not seen before, then comparing their answers with the library’s results. That would be more like an evaluation than a unit test, but it could tell me how reliably different assistants were able to follow the instructions. That's probably the closest I can get to unit testing the natural language instructions.
I suspect the best answer will be a hybrid. I would not try to generate the entire article from source code; that would probably produce fairly dreadful prose. Instead, I could write the natural-language instructions for AI assistants while generating or verifying every worked example with structured results from the calculator library.
Conclusion
I do not yet know how much of the finished instructions I will write by hand and how much I can generate. What I do know is that I do not want them to become a second, untested version of the calculation. Their worked examples and concrete results should be produced or verified by the tested calculator library.
So yes, I still want to build an MCP server. It would give configured AI assistants a reliable way to call the calculator directly. The public instructions would serve a different purpose: they could make my calculation method available to assistants that had not been connected to the MCP server, and therefore to knitters who would never think to install a plugin.
One approach prioritizes reliable execution. The other creates the possibility of broader discovery.
Both begin in the same place. The calculator library still has to come first.
Comments