SovereignSpec Workflow Explanation

make this flow better and more concise: The way I made sovereignSpec is this. I created an agentic harness using Deer-Flow. In it I gave it access to the over 130 technical AI blog posts I have written. The harness is the part of the AI that allows it to act. Such as use commands and functions in its output. So for instance instead of hallucinating a response to something it does not know it would use the <search_web> tool call in its output which is then read by the harness and executes commands with your computer. These commands can be anything you can use a computer to do. So within this agentic harness in Deer-Flow I built a knowledge bank. In the knowledge bank is the 130+ blog posts. But I do not have the posts simply stored as markdown files. Rather I index them into vector and graph databases. That means nothing to a human as if you were going through the documents looking for something you would never use the vector or graph databases to figure out what is in the documentation. But an agent powered in this case by my local LLM, can read all of that very well and it allows you to do many things. I wish I could go into explaining what a graph database is and the power it gives you to represent or sort through information or what a vector database is and how it allows you to mathematically compare values along embedded parameters, but I think that would take too long. But back to how I made sovereignSpec, I took that setup and asked it to construct a project for me which researched current trends and integrated what I have been working on into a new project. And it gave me the “spec” for sovereignSpec. Next I take that spec and ask a coding agent to create the documentation using my https://github.com/kliewerdaniel/workflow.git or Spec Kit which is a better maintained version created by the community. Spec Kit then creates the documentation. Next I use a coding agent, I use OpenCode to code the project. Once it is complete I upload it to GitHub. Then I use my agentic harness again, which has functions to download from GitHub or interact with it and it then analyzes the repo and I have it output a list of corrections which need to be made. Then I take that and give it to the coding agent. I repeat that loop back to uploading to GitHub and using the harness until I can get it running the rest of the way on my own to test. After that I have to test and debug it. Then once I had sovereignSpec made I used sovereignSpec in this workflow to generate new software from it, which is what https://github.com/kliewerdaniel/specweave.git is. What is remarkable about this is that using this method you can quickly make software. All I have to do now to make new software is ask the agent to use a skill I created for it, skills are another whole thing I won’t go into, it is a folder for each with a SKILL.md which is basically a recipe with all the ingredients compiled. I included that skill I wrote for it in the documentation, but what it allows you to do is now simply tell the agent, whether it be the one I have in my coding agent in OpenCode or the one I use with my harness and local set up, both have access to this python package and can now use it simply by calling the application. So you see, this software is made for both AI and humans to use. So now I can take the previous workflow and reduce it down to: Tell the coding agent what I want to build and ask it to use sovereignSpec to generate a .sspec file for the project after asking me enough clarifying questions to complete. Now with this one file, which is human readable, the entire file system for sovereignSpec is generated and now a fully fleshed out specification which contains the graph and vector databases and provenance of decisions made for design decisions and such. This allows both a team of human developers or coding agents to plan and create the documentation for the application. Because that is all I have to do now is provide the .sspec file and simply tell a coding agent “Build this .sspec file using sovereignSpec” and that is all I said to build https://github.com/kliewerdaniel/specweave.git I won’t even start to go into what specWeave is, it is more advanced, and I glossed over most of the technical details as well. But now the question is, who really made this? Me or the AI? It was I who provided all of the blog posts which is what the harness read in order to construct the spec for this application, but did I even write the blog posts? No, those were also partly written by me and partly by AI as well. That is one application of what I have made. Think of it this way. You go to a website and did you know that from Chrome Developer Panel in the browser you can download the entire website as a .har file? Then you can make a new folder and place it there and ask a coding agent to analyze the .har file and reverse engineer the entire site and make a .sspec file using sovereignSpec which will rebuild the page the same or better. I did just this with my friend’s page. His page was awful, https://dealcannon.org and I made it https://dealcannon.vercel.app But this method allows you to automate the entire process. Now I could build a SKILL.md for my agent which would do all of this workflow, take the website, download the .har, reverse engineer it and write a .sspec file for it and then rebuild it using the .sspec file the same or better. Now I could simply ask the agent, go to his page and rebuild it but better and it can do so. Just like I did with dealcannon above.

Here's a tighter, more readable version that preserves the core ideas while reducing repetition and improving flow: :::writing{variant="document" id="58241"} SovereignSpec emerged from a workflow I built around an agentic AI harness running on top of Deer-Flow. The harness provides the AI with the ability to act rather than simply generate text. Instead of hallucinating answers, it can invoke tools such as web search, file operations, GitHub interactions, local scripts, and other functions. When the model decides it needs information or needs to perform an action, it emits a tool call, and the harness executes it. The foundation of this system is a knowledge bank built from more than 130 technical AI blog posts I have written. Rather than storing those posts as simple markdown files, I index them into vector and graph databases. To a human, these databases are not particularly useful for reading documentation, but for an AI they provide powerful ways to retrieve, connect, and reason about information spread across hundreds of documents. Using this environment, I instructed the agent to research current trends, combine them with concepts from my existing work, and propose a new project. The result was the initial specification for SovereignSpec. From there, I feed the specification into a documentation-generation workflow based on my Workflow project or Spec Kit, a community-maintained implementation of similar ideas. This generates the project documentation and development plan. I then use a coding agent—typically OpenCode—to implement the project. Once the code is complete, I publish it to GitHub. My agentic harness can then clone, analyze, and evaluate the repository, generating a list of corrections, improvements, and missing functionality. Those recommendations are fed back into the coding agent, creating an iterative loop: Specification → Documentation → Implementation → GitHub → Analysis → Corrections → Implementation I repeat this cycle until the software reaches a stage where I can manually test and debug the remaining issues. After SovereignSpec was complete, I used SovereignSpec itself within this workflow to generate additional software. One example is SpecWeave. In many ways, SpecWeave is a product created by SovereignSpec, which itself was created through a combination of my knowledge base, agentic tooling, and AI-assisted development. The most significant outcome is that software creation becomes dramatically faster. Rather than manually constructing every project from scratch, I can provide an agent with a reusable skill—a structured recipe stored as a SKILL.md file—and allow it to execute a large portion of the workflow automatically. SovereignSpec is designed for both humans and AI systems. The key artifact is a human-readable .sspec file. Instead of writing extensive documentation manually, I can simply tell a coding agent what I want to build, answer a series of clarifying questions, and have it generate a complete .sspec specification. From that single file, SovereignSpec generates a complete project structure, documentation framework, graph relationships, vector indexes, provenance records, and architectural decisions. The resulting specification can be used equally well by human developers or coding agents. In practice, building a new project is now reduced to a simple instruction: "Generate a .sspec file for this idea, then build it using SovereignSpec." That is essentially the process used to create SpecWeave. The implications extend beyond greenfield development. For example, a website can be downloaded as a HAR file from a browser. An agent can analyze that HAR file, reverse-engineer the site's behavior and structure, generate a .sspec representation, and then rebuild the application from the specification. I recently used this approach to redesign a friend's website. Instead of manually rebuilding the site, I had the agent analyze the existing implementation, construct a specification, and generate an improved version. The process can itself be automated through a reusable skill, allowing an agent to perform the entire sequence—from downloading the website to generating the specification to rebuilding the application—through a single high-level instruction. At that point, software development begins to look less like traditional programming and more like specification engineering. Which raises an interesting question: who actually created SovereignSpec? I supplied the knowledge base. The agent synthesized the specification. The coding agent implemented much of the code. Yet even the knowledge base itself was created through years of collaboration between myself and AI systems. The result is neither purely human nor purely artificial. It is a new form of software creation in which humans increasingly contribute intent, judgment, and accumulated knowledge while AI systems contribute synthesis, implementation, and iteration. :::

try again with this : The way I made sovereignSpec is this. SovereignSpec emerged from a workflow I built around an agentic AI harness running on top of Deer-Flow. The harness provides the AI with the ability to act rather than simply generate text. Instead of hallucinating answers, it can invoke tools such as web search, file operations, GitHub interactions, local scripts, and other functions. When the model decides it needs information or needs to perform an action, it emits a tool call, and the harness executes it. The foundation of this system is a knowledge bank built from more than 130 technical AI blog posts I have written. Rather than storing those posts as simple markdown files, I index them into vector and graph databases. To a human, these databases are not particularly useful for reading documentation, but for an AI they provide powerful ways to retrieve, connect, and reason about information spread across hundreds of documents. Using this environment, I instructed the agent to research current trends, combine them with concepts from my existing work, and propose a new project. The result was the initial specification for SovereignSpec. From there, I feed the specification into a documentation-generation workflow based on my Workflow project or Spec Kit, a community-maintained implementation of similar ideas. This generates the project documentation and development plan. I then use a coding agent—typically OpenCode—to implement the project. Once the code is complete, I publish it to GitHub. My agentic harness can then clone, analyze, and evaluate the repository, generating a list of corrections, improvements, and missing functionality. Those recommendations are fed back into the coding agent, creating an iterative loop: Specification → Documentation → Implementation → GitHub → Analysis → Corrections → Implementation I repeat this cycle until the software reaches a stage where I can manually test and debug the remaining issues. After SovereignSpec was complete, I used SovereignSpec itself within this workflow to generate additional software. One example is SpecWeave. In many ways, SpecWeave is a product created by SovereignSpec, which itself was created through a combination of my knowledge base, agentic tooling, and AI-assisted development. The most significant outcome is that software creation becomes dramatically faster. Rather than manually constructing every project from scratch, I can provide an agent with a reusable skill—a structured recipe stored as a SKILL.md file—and allow it to execute a large portion of the workflow automatically. SovereignSpec is designed for both humans and AI systems. The key artifact is a human-readable .sspec file. Instead of writing extensive documentation manually, I can simply tell a coding agent what I want to build, answer a series of clarifying questions, and have it generate a complete .sspec specification. From that single file, SovereignSpec generates a complete project structure, documentation framework, graph relationships, vector indexes, provenance records, and architectural decisions. The resulting specification can be used equally well by human developers or coding agents. In practice, building a new project is now reduced to a simple instruction: “Generate a .sspec file for this idea, then build it using SovereignSpec.” That is essentially the process used to create SpecWeave. The implications extend beyond greenfield development. For example, a website can be downloaded as a HAR file from a browser. An agent can analyze that HAR file, reverse-engineer the site’s behavior and structure, generate a .sspec representation, and then rebuild the application from the specification. I recently used this approach to redesign a friend’s website. Instead of manually rebuilding the site, I had the agent analyze the existing implementation, construct a specification, and generate an improved version. The process can itself be automated through a reusable skill, allowing an agent to perform the entire sequence—from downloading the website to generating the specification to rebuilding the application—through a single high-level instruction. At that point, software development begins to look less like traditional programming and more like specification engineering. Which raises an interesting question: who actually created SovereignSpec? I supplied the knowledge base. The agent synthesized the specification. The coding agent implemented much of the code. Yet even the knowledge base itself was created through years of collaboration between myself and AI systems. The result is neither purely human nor purely artificial. It is a new form of software creation in which humans increasingly contribute intent, judgment, and accumulated knowledge while AI systems contribute synthesis, implementation, and iteration. — So that is my answer to whether I made it. I would almost say the process I used to make it is more valuable than the actual software since it is a highly specific set up that I have developed. Another thing, is that I did all of that for free. Most AI companies charge for this kind of workflow and make a lot of their money selling these automations to corporate America. But what corporate America is slowly starting to figure out through the spread of work like my own is that the sale the big AI companies are giving is not entirely truthful since so much of what they offer can simply be created now using set ups such as my own entirely for free. What I can offer is this. I can set up your computer to be able to have an agent be able to do anything the big AI companies are trying to sell you through subscription based software but all for free forever. Since it is all local you do not need the internet to run it and if there is ever an outage you will not be affected. I find myself using the local agent set up I have more than openAI or Anthropic or Google’s options now, since this set up have more functionality. But what I could demo is to show how you can easily reverse engineer a site using sovereignSpec, that was not the original intention of the project, but I think it is one of the coolest applications of it and then have the coding agent rebuild the site entirely. All through a single high level request to the agent.

This version keeps your voice and argument but tightens the narrative and makes the progression easier to follow: :::writing{variant="document" id="61427"} The way I made SovereignSpec is actually more interesting than the software itself. SovereignSpec emerged from a workflow I built around an agentic AI harness running on top of Deer-Flow. The harness gives the AI the ability to act rather than simply generate text. Instead of hallucinating answers, it can invoke tools such as web search, file operations, GitHub interactions, local scripts, and other functions. When the model decides it needs information or needs to perform an action, it emits a tool call and the harness executes it. The foundation of this system is a knowledge bank built from more than 130 technical AI blog posts I have written over the past several years. Rather than storing those posts as simple markdown files, I index them into vector and graph databases. To a human, these databases are not particularly useful for reading documentation, but for an AI they provide powerful ways to retrieve, connect, and reason about information spread across hundreds of documents. Using this environment, I instructed the agent to research current trends, combine them with concepts from my existing work, and propose a new project. The result was the initial specification for SovereignSpec. From there, I fed the specification into a documentation-generation workflow based on my Workflow project and Spec Kit. This generated the project documentation and development plan. I then used a coding agent—typically OpenCode—to implement the project. Once the code was complete, I published it to GitHub. My agentic harness could then clone, analyze, and evaluate the repository, generating a list of corrections, improvements, and missing functionality. Those recommendations were fed back into the coding agent, creating an iterative loop: Specification → Documentation → Implementation → GitHub → Analysis → Corrections → Implementation I repeated that cycle until the software reached a stage where I could manually test and debug the remaining issues. After SovereignSpec was complete, I used SovereignSpec itself to generate additional software. One example is SpecWeave. In a very real sense, SpecWeave was created by SovereignSpec, which was itself created through a combination of my knowledge base, agentic tooling, and AI-assisted development. The most important outcome is not any individual application. It is the reduction of software development into a repeatable process. Rather than manually constructing every project from scratch, I can provide an agent with a reusable skill—a structured recipe stored in a SKILL.md file—and allow it to execute large portions of the workflow automatically. SovereignSpec itself is designed for both humans and AI systems. The key artifact is a human-readable .sspec file. Instead of writing extensive documentation manually, I can simply tell a coding agent what I want to build, answer a series of clarifying questions, and have it generate a complete .sspec specification. From that single file, SovereignSpec generates a complete project structure, documentation framework, graph relationships, vector indexes, provenance records, and architectural decisions. The resulting specification can be used equally well by human developers or coding agents. In practice, creating a new project is now reduced to a simple instruction: "Generate a .sspec file for this idea, then build it using SovereignSpec." That is essentially the process used to create SpecWeave. The implications extend far beyond creating new software from scratch. Consider a website. Modern browsers allow you to export a complete HAR file containing the network activity and structure of a page. An agent can analyze that HAR file, reverse engineer the site's behavior and architecture, generate a .sspec representation, and then rebuild the application from the specification. I recently used this approach to redesign a friend's website. Rather than manually rebuilding the site, I had the agent analyze the existing implementation, construct a specification, and generate an improved version. The entire process can itself be automated through a reusable skill, allowing an agent to perform the entire sequence—from downloading the website, to generating the specification, to rebuilding the application—from a single high-level request. At that point, software development begins to look less like programming and more like specification engineering. Which raises an interesting question: who actually created SovereignSpec? I supplied the knowledge base. The agent synthesized the specification. The coding agent implemented much of the code. Yet even the knowledge base itself was created through years of collaboration between myself and AI systems. The result is neither purely human nor purely artificial. It is a new form of software creation in which humans increasingly contribute intent, judgment, domain knowledge, and goals while AI systems contribute synthesis, implementation, and iteration. So when people ask whether I made SovereignSpec, my answer is yes—but I would also argue that the process used to create it may be more valuable than the software itself. The workflow is the invention. What makes this particularly interesting is that I built the entire system using free and open-source tools. Much of the AI industry currently sells variations of these workflows back to businesses as subscription products. There is certainly value in convenience, support, and managed infrastructure, but the underlying capabilities are increasingly accessible to anyone willing to assemble the pieces themselves. What I can offer is not another subscription. I can show people how to set up a local-first system that gives them many of the same capabilities being marketed by large AI companies, while retaining control over their own data, infrastructure, and workflows. Because the system runs locally, it continues to function regardless of internet outages, API changes, or shifting pricing models. In fact, I increasingly find myself using my local agent environment more than the offerings from OpenAI, Anthropic, or Google for certain types of work simply because it has direct access to my tools, knowledge base, and workflows. One of the most compelling demonstrations of this approach is website reconstruction. Although it was never the original purpose of SovereignSpec, it illustrates the power of specification-driven development remarkably well. I can point an agent at an existing website, have it analyze and model the system, generate a specification, and then rebuild the application from that specification—all through a single high-level request. That is the direction I believe software development is moving: away from writing code line by line and toward designing systems that can translate human intent into executable specifications. :::

:::writing{variant="document" id="48172"} The way I built SovereignSpec was by first creating an agentic AI harness on top of Deer-Flow. The harness gives an AI the ability to act, not just generate text. Instead of guessing answers, it can search the web, interact with GitHub, run scripts, manipulate files, and perform other tasks through tool calls. The harness is backed by a knowledge bank containing more than 130 technical AI blog posts I have written. Those posts are indexed into vector and graph databases, allowing the AI to retrieve concepts, discover relationships, and reason across a large body of knowledge far more effectively than by reading raw files alone. Using that environment, I asked the agent to research current trends, combine them with ideas from my existing work, and propose a new project. The result was the initial specification for SovereignSpec. That specification is then fed into a documentation workflow based on my Workflow project or Spec Kit. Once the documentation is generated, I use a coding agent such as OpenCode to implement the software. After the code is pushed to GitHub, the harness analyzes the repository, identifies issues and improvements, and feeds those corrections back into the coding agent. The process becomes a continuous loop: Specification → Documentation → Implementation → Analysis → Corrections I repeat that cycle until the software is stable enough for manual testing and debugging. Once SovereignSpec existed, I used it to create new software. SpecWeave is an example of a project generated through this workflow. The important thing is not the individual application but the process itself. Instead of starting every project from scratch, I can provide a coding agent with a reusable skill and a human-readable .sspec file. Today, building a project is often reduced to a simple instruction: "Generate a .sspec file for this idea and build it using SovereignSpec." From that single specification, SovereignSpec generates documentation, project structure, architectural decisions, provenance records, and knowledge representations that both humans and AI systems can work from. This approach also extends beyond new projects. A website can be captured as a HAR file, analyzed by an agent, converted into a .sspec specification, and rebuilt automatically. I recently used this technique to redesign a friend's website by having the agent reverse engineer the existing implementation and generate an improved version. At that point, software development begins to look less like programming and more like specification engineering. When people ask whether I made SovereignSpec, the answer is complicated. I supplied the knowledge base and designed the workflow. The agents synthesized specifications, generated documentation, and wrote much of the implementation. The result is neither purely human nor purely AI—it is a collaborative process. In many ways, the workflow is more valuable than the software itself. Most AI companies sell versions of these capabilities as subscription services. My view is that much of this functionality can now be recreated using local, open tools. What I can offer is a setup that gives individuals and organizations many of the same agentic capabilities without ongoing subscription costs and without depending on cloud services. One of the most compelling demonstrations is showing an agent reverse engineer a website, generate a SovereignSpec specification from it, and then rebuild the site from that specification—all from a single high-level request. :::