I have been spending a lot of time using AI coding tools recently. They are surprisingly good at writing code, explaining unfamiliar parts of a project, and helping with repetitive work.
But I kept running into a problem that was not really about the model.
The problem was everything around the model.
Where should the instructions live? How should I organize reusable workflows? How do I share the same engineering standards between projects? What happens when I want to use a different AI coding tool?
That is why I started building @mohammadhprp/system-prompt.
The part that feels fragmented
Different AI coding tools have different ways of configuring agents. Some use instruction files. Some have skills, commands, plugins, modes, or their own configuration format.
The names and formats are different, but the needs are often the same.
I usually want my agent to:
- Follow the engineering standards of the project
- Use a repeatable process for common tasks
- Remember useful project context
- Connect to tools such as GitHub, a database, or documentation
- Review its own work instead of only generating code
- Work with fewer unsafe assumptions
I found myself recreating parts of this setup again and again. A new project meant another round of copying instructions, choosing tools, and deciding how the agent should behave.
That repetition made me wonder whether this should be a framework instead of a collection of unrelated configuration files.
The idea behind System Prompt
I use harness to describe the environment around an AI model.
The harness includes the instructions, tools, permissions, workflows, memory, integrations, and standards that influence how an agent works. The model matters, but the harness also has a big effect on the quality and safety of the result.
My idea is simple:
AI coding tools should be able to share more of the framework around the model, not only the model itself.
This is still an idea, not a finished standard. I am trying to understand which parts can be shared and which parts will always need to remain specific to each client.
Why MCP gave me this idea
The Model Context Protocol is a good example of what interoperability can look like.
Before MCP, connecting an AI application to an external tool often meant dealing with client-specific integrations. MCP provides a shared way to expose tools and context.
That made me think: could we use a similar approach for other parts of the coding-agent harness?
For example, could a skill describe a workflow in a portable way? Could an agent role declare its capabilities and permissions? Could a command work across multiple clients through small adapters?
I do not think everything needs to be identical. Different tools can still have different interfaces and user experiences. But the underlying building blocks could be described consistently.
What the package does today
System Prompt is an interactive CLI. It helps install selected parts of an AI coding-agent framework into a project instead of asking users to copy everything manually.
You can try it with Node.js 18 or newer:
npm install -g @mohammadhprp/system-prompt
Run it from your project directory:
system-prompt
The CLI lets you choose what to install. The framework currently includes:
- Skills for repeatable procedures
- Specialized agents for tasks such as research, architecture, code review, and security
- Commands for common workflows
- MCP documentation and configurations
- Plugins and behavior modes
- Project memory
- Design references
- Engineering standards and templates
The important part for me is that these are separate, documented components. I do not want one huge system prompt that an agent has to read every time. I want smaller capabilities that can be selected and used when they are relevant.
What a shared framework might need
If this idea grows beyond one project, I think a shared framework would need more than a directory of prompts.
It would probably need:
- A common description format for skills, agents, commands, and integrations
- Version and compatibility information
- Clear permissions and capability declarations
- Client adapters where formats are different
- A way to validate components before installing them
- A registry for discovering and sharing components
- A way to preserve project context without locking it to one vendor
Security is especially important here. An AI tool may be able to read files, run commands, access a database, or change project state. A framework should make those capabilities visible instead of hiding them in a prompt or configuration file.
This is an experiment
I am not presenting System Prompt as the answer, and I am not saying that the industry needs one tool to control all AI coding agents.
I am exploring a direction that feels useful to me: a central, extensible framework for the harness around AI coding tools.
The project is open source and available under the MIT license:
I would really like feedback from people who use AI coding agents regularly.
- Which parts of your setup do you keep recreating?
- Do you switch between multiple AI coding tools?
- What would you want to be portable between them?
- What should a shared framework guarantee before you would trust it?
The question I keep coming back to is this:
If MCP can give AI applications a shared way to connect to tools, can we also create a shared way for AI coding agents to operate inside software projects?
Top comments (0)