I am about to make two of my codebases public.
One is the multi-agent RFP responder I have posted about before (which I use to respond to RFP’s). The other is an RFP assessor.
I spent a fair bit of time thinking about whether I should try to turn them into products. There was a period where that felt like the natural next step. Build something useful, prove that it works, then package it up. But the more I reflected on it, the more I found myself landing somewhere else.
For me, these projects were never just about producing a software asset. They were a way to learn by building. A way to get properly hands-on with
• MCP
• Docling
• Multi-agent workflows
• Shifting from VSCode to Anthropic Claude Code
• Microsoft Agent Framework (MAF)
• Expressing non-functional requirements as code to influence how a build behaves (i.e.repository analysis and generating Gherkin-style requirements to help enforce build characteristics)
• Selecting local Ollama hosted models vs. remote frontier models for use-cases
So yes, the code matters, but I think what mattered more to me was everything that came with building it. The experimentation. The false starts and failures. The moments where something finally clicked. The practical lessons that only seem to come when you are actually trying to make the pieces work together in a way that is useful, and I think that is part of why I have become more comfortable with opening this work up.
The other reason is that I can feel the ground shifting.
The ability to automate tasks is improving quickly. Code generation is improving quickly too. And that makes me question how durable this sort of functionality really is as a protected product. What feels differentiated today may not stay difficult to reproduce for very long. That does not make the work less valuable, but it does make me think the value may sit in a different place than it once did:
• Less in keeping the artifact closed.
• More in the learning that came from building it.
• More in the judgment that develops through experimentation.
• More in the ability to apply these patterns in real situations, with real constraints, for real use-cases.
So this feels like the right call. Partly because others may find it useful, and partly because I suspect we are going to see more builders wrestling with the same question: when the cost of implementation keeps falling, where does the real value actually sit?
More and more, I think it sits in the doing, and in what the doing teaches you.
RFP Responder: https://github.com/steveh250/RFP-Responder-Public
RFP Assessor: https://github.com/steveh250/RFP-Assessor-Public